Como sei quando refatorar as chamadas de consulta de banco de dados global e quando deixá-las em paz?

Eu tenho as seguintes chamadas de instruções globais espalhadas em toda a minha base de código legado do PHP:

$jobnumber = db_quick($sql);
db_query($sql);

Ou seja, essas chamadas de função foram inicializadas no escopo global e elas mesmas chamam um objeto global do MySQL anteriormente inicializado, ou seja:

//initializes MySQL connection object in the global scope
$dblink = MySqlConnector::getMySql();

function db_query($sql)
{
    //previously initialized MySQL connection object
    global $dblink;  

    //native MySQL API call:
    return mysqli_query($dblink, $sql);
}

Pergunta

Há algum benefício em refatorar essas declarações globais, além de apenas dizer "Eu as removi agora do escopo global"?

O espírito da minha pergunta é ... esses já estão na base de código e funcionam. Eu devo mexer com eles? Até agora [3 anos trabalhando com o código] não houve nenhum dano aparente. Mesmo com a transição do mysql obsoleto para o mysqli, foi uma transição indolor. Será que mantê-los como globais causará algum dano mensurável mais tarde? São bons o suficiente para ficarem como estão?

E se eu refatorar?

A propósito, se eu refatorar estou pensando em usar um padrão Singleton para instanciação de link de banco de dados e, em seguida, chamá-lo através de uma classe instanciada, que chama o Singleton. Assim:

//in a calling class:
$repository = new GenericRepository();
$repository->getMySql()->persist($sql);
$value = $repository->getMySql()->paramQuery($sql, $param);

//GenericRepository makes a static call to the actual connector
class GenericRepository 
{
    final public function getMySql()
    {
        if ($this->link === null)
            $this->link = MySqlConnector::getMySql();

            return $this->link;
    }
}

//Connector calls MySQL API
class MySqlConnector
{

    public static function getMySql()
    {
        if (null === static::$instance)
        {
            include 'include/config.php';

            //class MySql extends mysqli library
            static::$instance = new MySql(DBHOST, DBUSER, DBPASS);
        }

        return static::$instance;
    }
}

Portanto, em essência, refatorando, removerei os métodos de banco de dados globais e os substituirei por chamadas instanciadas para o padrão Singleton. A alteração do código será bastante extensa, já que existem algumas milhares de chamadas globais de banco de dados.

Efeitos da Refatoração acima

Atualmente, posso chamar os métodos "de qualquer lugar" - eles são globais.

db_query($sql);    

Após a refatoração, ainda serei capaz de chamá-los "de qualquer lugar", mas usando uma string de conexão mais longa.

(new \Namespace\GenericRepository())->getMySql()->persist($sql);

Isso soa um pouco como um prejuízo - uma string mais longa, mais para digitar, mais para copiar & colar. Existem realmente alguns benefícios para isso?