[Flecha]

Ya he encontrado una solución. No es la que más me gusta, pero era la única posible.

En fin. Resulta que la clase TDataSet contiene una variable llamada FDataSources (de tipo TList) que contiene la lista de todos los TDataSources que apuntan a dicho TDataSet. Cuando a la propiedad DataSet de un TDataSource se le asigna un TDataSet, dicho TDataSource es añadido a dicha lista FDataSources del TDataSet al que apunta. Y cuando se asigna nil, el TDataSource es borrado de dicha lista.

Cuando se producen eventos en el TDataSet, éste hace uso de su lista FDataSources para "despertar" los eventos de los TDataSource que estén apuntando al TDataSet. Por tanto, los eventos de TDataSource que se ejecutan antes son los de aquellos TDataSource que estén los primeros de la lista FDataSource.

Para solucionar mi problema me habría bastado con acceder a la lista FDataSource y hacer uso de su método Move() (ya que es de tipo TList) para cambiar el orden de los TDataSource contenidos en ella y poner el mío el primero de la lista. Pero por desgracia, tanto FDataSource como los procedimientos que lo manejan son private, así que no se puede acceder a ellos desde fuera.

Así que he optado por otra solución. Partiendo de la variable global Application he buscado todos los TDataSource creados dentro de la aplicación y que estén apuntando al TDataSet en concreto. A todos esos TDataSource les rompo su relación con el TDataSet para que desaparezcan de la lista FDataSource. Después les vuelvo a relacionar con su TDataSet y al ser incorporados de nuevo a la lista FDataSource son incorporados al final de la misma. Conclusión: he conseguido que mi TDataSource pase al primer lugar de dicha lista y que sus eventos sean los primeros de todos en ejecutarse.
Misión cumplida.

Aquí os paso el código fuente del procedimiento que me hace eso que os comento, por si a alguien le valiera de algo:

Código Delphi [-]
    procedure ReOrdenarDataSource(Componente:TComponent; MiDataSource:TDataSource);
    var x:integer;
    begin
      //==================
      // Este procedimiento asegura que los eventos de mi TDataSource local
      // se ejecuten antes que ningún otro TDataSource que apunte al mismo
      // TDataSet.
      //==================
      //------ Recorro los componentes contenidos
      for x:=0 to Componente.ComponentCount-1 do begin
        //------ Si a su vez puede contener TDataSource, entro en él
        if (Componente.Components[x] is TForm)
        or (Componente.Components[x] is TDataModule)
        or (Componente.Components[x] is TQuickRep)
        Then Begin
          ReOrdenarDataSource(Componente.Components[x], MiDataSource);
          Continue;
        End;
        //------ Busco otros TDataSource que apunten al mismo TDataSet
        {$B-}
        if (not (Componente.Components[x] is TDataSource))
        or (not (TDataSource(Componente.Components[x]).DataSet = MiDataSource.DataSet))
        or (Componente.Components[x] = MiDataSource))
        then Continue;
        //------ Rompo la relación entre el TDataSource y el TDataSet
        TDataSource(Componente.Components[x]).DataSet := nil;
        //------ Vuelvo a relacionar el TDataSource con el TDataSet
        TDataSource(Componente.Components[x]).DataSet := MiDataSource.DataSet;
      end;
    end;

La llamada a este procedimiento es esta:

Código Delphi [-]
  ReOrdenarDataSource(Application, MiDataSourceLocal);

Un saludo a todos.