Is there a way to copy the drivers of the active object
The answer is Ctrl + L then choose Animation Data, as "Serge L" mentioned in his comment, however there are limitations in my specific case, or whenever Distance is used as a factor.
The limitation is, when you duplicate an object that has drivers, Blender is smart enough to know, if the object itself is a factor in the distance, that the name of the duplicate object is to be used as a factor, this, unfortunately, doesn't happen when you copy Animation Data from one object to another, check the images below for explanation on what I mean.
While when copying Animation Data, it doesn't amend the object in distance factor in the driver

So in the case where a distance between two objects is the factor in the driver, there don't seem to be a solution, but in other cases where a simple location factor is used, copying animation data is the answer.
Aside from that, in order to find a solution for my case, I discarded the use of drivers, I coded a script instead to do that, here it is :

import bpy
###Parameters
#Change these parameters
#the following target_name variable
#will target all objects in scene that
#have "Cube" in there name
#factor is devision factor based on distance from active object "controller"
#when you run the script, register should be checked here in text editor
#and the controller should be the active object
#the script will run on each frame change

target_name = "Cube"
factor = 20

###End parameters

starting_frame = bpy.context.scene.frame_current
target_list =[]
act = bpy.context.object

#Populate a list of targets based on name
for t in bpy.context.scene.objects:
    if target_name in t.name:
        target_list.append(t) 


def run_script(scene):
    global starting_frame
    print("-------------------------")
    run_frame = bpy.context.scene.frame_current
    print(run_frame)
    for target in target_list:
        distance_v = act.location-target.location
        distance = pithag(act.location,target.location)
        print(distance)
        if run_frame != starting_frame:
            target.scale.x = distance/factor
            target.scale.y = distance/factor
            target.scale.z = distance/factor
    starting_frame = run_frame
    print(starting_frame)

#Calcualte linear distance between target an controller "active object"  
#Both arguments should be 3D vector  
def pithag(vec1, vec2):
    dist = ((vec1[0]-vec2[0])**2) + ((vec1[1]-vec2[1])**2) + ((vec1[2]-vec2[2])**2)
    return dist

#Script will run on frame change
bpy.app.handlers.frame_change_pre.append(run_script) 


And here's a GIF of the result, the diference is, here I can edit the variables in the script, and it'll apply to all targeted objects

NOTE: In order to stop the targets from getting very large when the distance is great, I added Limit Scale constraint to the targets.