Can the reproduction function of an evolutionary algorithm consider gene strength?
Can the reproduction function which determines how speciemen (solution attempts) reproduce take into account some kind of gene strength to also determine which genes are best to be passed down to the child of two speciemen?


Of course it can.

Anyway, consider that in GA this already happens implicitly. Using the established methods and genetic operators of genetic algorithms (not only reproduction but also crossover and mutation) the Holland's schema theorem states that low-order schemata with above-average fitness increase exponentially in successive generations.

(a schema is a template that identifies a subset of strings with similarities at certain string positions)

In Genetic Programming things are different:


GA representations are often fixed size whereas GP representations and usually variable sized;
GA normally have a semantic interpretation for a given location in a chromosome while GP solutions often do not exhibit location dependent meanings.


John Koza attempted to explain why genetic programming works by extending Holland's schema model and theorem to GP but with various differences / limitations (the class of problems and problem representations for which block processing is useful remains a challenging and open research topic in GP).

In GP your idea is the base of the modularization approach, e.g.


The encapsulation operation is a genetic operation that identifies a 
potential useful subtree and gives it a name so that it can be referenced and used later (see Genetic Programming: On the Programming of Computers 
by Means of Natural Selection)
Better yet, Adapting Representation through Learning (ARL). With ARL New subroutines are created using blocks of genetic material from the pool 
given by the current population.

The detection of what are salient blocks of code is based on two notions: differential offspring-parent fitness and "active" blocks.

The process of discovering building blocks and creating new subroutines based on simple blocks of code is applied recursively so that subroutines of 
any complexity can be discovered.

Subroutines beneficial to some individuals could be invoked also by other individuals. The end result is the collection of subroutines that acquires the necessary structure for solving the problem (take a look at Towards Automatic Discovery of Building Blocks in Genetic Programming by Justinian Rosca for a complete description).