
<p class="has-drop-cap">1 Årets första finaler i Solvallaserien avgörs ikväll och ett koppel segervana hästar gör upp om 150.000 kronor vardera i de tre klasserna. Medan vinterns försök avgjorts under barfotaförbudet är det fritt fram att rycka skorna ikväll om banunderlaget tillåter. Det utnyttjar två- tredjedelar av finalisternas tränare, 24 av 36 hästar är anmälda med någon form av barfotabalans.</p>



<p>Det kanske hetaste mötet på förhand kommer i lägsta klassen, där varken Katja Melkko eller Morten Waage däremot plockar av några skor bakom sina segerstaplare <strong>Relevant Stride</strong> (e. Maharajah) respektive <strong>Spike M.M.</strong> (e. Beanie M.M.).<br>Att det handlar om två travare som vet var mållinjen ligger råder inga tvivel om. Spike M.M. vet efter fyra starter i vinter fortfarande inte hur det känns att förlora. Finskfödda Relevant Stride å sin sida har sex raka segrar bakom sig efter att ha inlett karriären med galopp och en tredjeplats.</p>



<p>En nyhet i årets Solvallaserie är att ston har fördel penningmässigt i de olika klasserna och i den högsta – max 650.000 kronor i grundproposition – finns faktiskt en miljonärska i finalfältet. Jevgeni Ivanovs norskföldda sto <strong>J.J.Another Win</strong> (e. Make It Happen) har haft en lysande vinter och försök försök i Solvallaserien har hon vunnit dubbla lopp i diamantstoet inom STL. Där väntar dessutom final på Solvalla om tio dagar.<br>Snubblande nära miljonen insprunget är även en av motståndarna, Marcus Schöns <strong>Jurista</strong> (e. Ready Cash), medan rikaste hingst/valack i fältet är <strong>Mateo di Quattro</strong> (e. Bird Parker), som travat ihop 744.000 kronor.</p>



<p>I mellanklassen finns starka kort som färske STL-vinnaren <strong>Global Dependable</strong> (e. S.J.’s Caviar), forne Kriteriefinalisten <strong>Mister Jupiter</strong> (e. Ready Cash) och italienare <strong>Delon Grif</strong> (e. Varenne) med tre raka segrar.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">2Bjerke (första start kl. 18.27) agerar saxbana till Solvalla på V86-spelet denna onsdagkväll och där startar blott en svensktränad häst inom det stora streckspelet.</p>



<p>Det är Helena Edlund som beger sig till den norska huvudstaden med <strong>Rocket Boy </strong>(e. Googoo Gaagaa) som tävlar i V86-inledningen och som nu jagar revansch efter att inlett sin sejour hos Årjängsamatören med att sluta oplacerad.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/frodehamre-617x333.jpg" alt="" class="wp-image-450191"/><figcaption class="wp-element-caption">Frode Hamre. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>I samma lopp tävlar vad som mycket väl kan komma att bli kvällens största V86-favorit. Frode Hamre-tränade <strong>Princess Olivia </strong>(e. Muscle Hill) är ett segervant sto med sju segrar på 13 starter varav fyra fullträffar nu har kommit i följd.<br>– <em>Hon blir troligtvis över från start från spår ett då hon bara är hygglig från början. Normalt sett löser det sig ändå och hon kan vinna lopp från alla positioner; även dödens</em>, säger Frode Hamre till Trav og Galoppnytt.</p>



<p>Bjerke har stundtals haft svårt att locka stora fält till de gemensamma V86-dagarna, men ikväll är det åtminstone tre tio hästarsfält och ett lopp med 15 hästar som utgör deras avdelningar inom den stora streckspelsgåtan.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/02/06v86.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till Bjerke och Solvalla.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3Idag inleds årets säsong av den franska, rikstäckande löpningsserien Grand National du Trot.</p>



<p>Det avgöras 13 etapper ute på landsortsbanorna innan finalen som brukligt avgörs på Vincennes den första söndagen i december.</p>



<p>Det inledande GNT-loppet (€90.000) för året avgörs i Amiens (första start kl. 13.55) drygt 15 mil norr om Paris där det tävlas i vänstervarv på en 1.100 metersbana.</p>



<p>Att flera av de bättre hästarna på fransk mark tar en paus efter avslutat vintermeeting på Vincennes blir påtagligt då dagens lopp är direkt svagt även om favoriten <strong>Guide Moi Forgan</strong> (e. Neutron du Cebe) vann Prix du Jara (€75.000) på nationalarenan i mitten av januari.</p>



<p><strong>Såhär ser årets schema ut i Grand National du Trot:</strong></p>



<p><em>Datum – bana</em></p>



<ul class="wp-block-list">
<li>6 mars – Amiens</li>



<li>27 mars – Marseille</li>



<li>10 april – Lyon-La-Soie</li>



<li>24 april – Cordemais</li>



<li>22 maj – Le Croisé-Laroche</li>



<li>5 juni – Laval</li>



<li>19 juni – Bordeaux</li>



<li>7 augusti – Saint-Malo</li>



<li>11 september – Le Mans</li>



<li>25 september – Cherbourg</li>



<li>16 oktober – Saint-Galmier</li>



<li>6 november – Nantes</li>



<li>20 november – Toulouse</li>



<li>1 december – Vincennes (final)</li>
</ul>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4Det avgörs även två EU-lopp i Amiens vilka utgör dagens två sista lopp och där är det rikligt med svenskintressen.</p>



<p>I Prix Equiressources IFCE (€26.000) för sju- till elvaåringar som högst tjänat 170.000 euro gör Daniel Wäjerstens <strong>Global Above All </strong>(e. Love You) debut på fransk mark i lag med Jean Francois Senet som kusk och från samma volt startar svenskfödda duon <strong>Comand</strong> (e. Jocose) samt <strong>Hattusa</strong> (e. Timoko).<br>Från tillägg jagas de av <strong>Mellby Guard </strong>(e. Going Kronos) samt<strong> King Cole </strong>(e. Maharajah) i strid om segerchecken på 11.700 euro.</p>



<p>Prix Afasec (€26.000) för sadelhästar ser likaså fyra svenskfödda deltagare. Christoffer Erikssons <strong>Mulberry</strong> (e. Maharajah) testar på monté efter att slutat trea i debuten på fransk mark, Jörgen Westholms <strong>Ara</strong> (e. Maharajah) jagar sin andra sadelseger i lag med Alexis Collette, Jean Charles Piton bidrar med <strong>Madame af Djupmyra </strong>(e. Formula One) och så syns även Yves Desmets <strong>Beethoven</strong> (e. From Above) bland deltagarna.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/amiens-2024-03-06/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Amiens.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">5Den forne auktionsdyringen <strong>Hefner Am </strong>(e. Muscle Hill–She Loves You F.I.) 1.13,6am/801.700 kr har funnit nytt hem.</p>



<p>Efter att sålts för 1,6 miljoner på Wenngarn Yearling Sales år 2018 har hästen haft blickarna på sig karriären igenom och bitvis stått för &#8221;lördagsprestationer&#8221;, men på senare tid har framgångarna uteblivit.</p>



<p>I mitten av januari köptes hästen av Philip Jensen för 75.000 kronor på Travera-auktion och nu har valacken exporterats till Danmark och satts i träning hos Jeppe Juel.</p>



<p>Hefner Ams penningmässigt största seger av totalt sju på 45 starter togs i ett Klass II-försök på Bergsåker år 2021.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/08/0113hefneramuppp180813adamstromstalltz-617x506.jpg" alt="" class="wp-image-28608"/><figcaption class="wp-element-caption">Hefner Am som kostade 1,6 miljoner kronor vid Wenngarn-auktionen år 2018. Numera är han i dansk träning. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6Bergsåker (första start kl. 12.20) står som värd för dagens lunchtävlingar och i V4-avslutningen kommer en STL-bekant springare till start.</p>



<p>Östersundsproffset Tomas B Nilsson har har fått fin snurr på <strong>Luca di Quattro </strong>(e. Ready Cash) sedan sexåringen anslöt till hans stall i höstas med två segrar på sex starter.</p>



<p>Närmast kommer hästen från en andraplats i ett Klass I-försök på just Bergsåker den 17 februari bakom<strong> Judge Dredd Sisu</strong> (e. Bold Eagle) och kommer ha chansen att starta i Klass I-finalen på Solvalla den 23 mars.</p>



<p>Henrik Svensson har inlett året starkt med 14 kusksegrar på 72 starter och har ett starkt lunchkort i <strong>Swosh</strong> (e. Super Photo Kosmos) som är på jakt efter sin tredje raka Bergsåkersvinst detta år.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/02/240306.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7<strong>Hussard du Landret</strong> (e. Bird Parker)<a href="https://sulkysport.se/krossade-lopningsrekordet/" target="_blank" rel="noreferrer noopener"> slaktade världsrekordet då han vann Prix de Paris (€400.000) på 1.11,9/4.150 meter den 25 februari</a> och nu tycks hans nästa uppgift vara bestämd.<br>– <em>Jag tränade själv hästen i onsdags och han var smidig och fin. Nu är hästen på stuteriet Genes Diffusion i Vaiges och ska tränas lätt i två veckor så får vi se sedan hur vi ska lägga upp matchningen. Jag har anmält honom till Prix Kerjacques den 6 april på Vincennes och det är inte omöjligt att det blir nästa uppgift beroende på hur allt fortskrider den närmsta tiden</em>, säger hästens tränare Benoit Robin till Paris-Turf.</p>



<p>Prix Kerjacques innehar Grupp II-status och körs även 2.700 meter voltstart med en samlad prissumma på 120.000 euro.</p>

Fokustema
Morgonsvepet
Läs senare
Två tredjedelar växlar upp
Om finalkvällen på Solvalla, storloppsserien som kickar igång på de franska landsortsbanorna och nästa uppgift för en färsk världsrekordhållare går bland annat att läsa i dagens morgonsvep.
