
<p class="has-drop-cap">1En Kriterievinnare mot en Sprintermästartvåa i ett sprinterlopp, men en tredje häst vinner? Romme (första start 18.20) bjuder på ett litet men intressant snabblopp ikväll.</p>



<p>Daniel Redéns sitter själv upp bakom årsdebutanten <strong>Xanthis Harvey</strong> (e. Propulsion), som efter segern i Svenskt Travkriterium 2022 inte fick samma utdelning som fyraåring trots tre finalplatserer i klassiska lopp: Breeders Crown (fyra), Derbyt (femma) och Sprintermästaren (oplacerad).<br>– <em>Han gjorde en start i Frankrike (i Criterium Continental på julafton, reds. anm.) och gjorde ett djävulskt lopp. Han blev het som tusan i ledningen och drog i väg våldsamt. Förklaringen till det var att han blev riktigt sjuk efter det. Han fick penicillin och fick åka hem efter det. Han tappade en hel del, det satte sig både på kroppen på honom och i huvudet för han betedde sig konstigt efter det. Nu på slutet har han lugnat ner sig igen och känns normal. Detta är anledningen till att jag kör själv, jag vill bara att han kommer in i gängorna igen och vi börjar om. Han känns i alla fall fin</em>, säger Daniel Redén på Stall Zets hemsida.</p>



<p>Ulrika Wällstedts startblixt <strong>Sourire Frö </strong>(e. Wishing Stone) var tvåa i Sprintermästaren 2022 och har årsdebuten avklarad, då han hängde med fint efter sargresa.</p>



<p>Fast någon given match mellan dessa unghästmeriterade herrar är det inte tal om. Stefan P Pettersson vann spårlottningen med innerspår för sin snabbe silverdivisionshäst<strong> Comes With Age</strong> (e. Zola Boko), som gör årsdebut, och Jimmy H Anderssons <strong>Fortune Mearas</strong> (e. Dream Vacation) har varit igång i vinter på bra sätt.</p>



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



<p class="has-drop-cap">2Romme delar kvällens expresstrav med Östersund (första start 18.30). Norrmannen Noralf Braekkens <strong>Belfort Rags</strong> (e. Evil Enok M.E.) tillhörde kulltoppen i Norge som unghäst efter att bland annat ha vunnit Hans Petter Tholfsens Minneslopp som treåring och slutat tvåa i norska motsvarigheten till Sprintermästaren, Jarlsberg Grand Prix, året efter bakom Derbyvinnaren Charleston Volo (e. Classic Photo).</p>



<p>Efter att ha slutat oplacerad i sitt Derbykval som andrahandsfavorit sensommaren 2022 har hästen inte synts till i tävlingssammanhang, men ikväll i Östersund (första start 18.30) är det dags för comeback efter godkänt kvallopp på 1.19,7/2.300 meter på Orkla för en månad sedan.</p>



<p>Belfort Rags har blivit kastrerad under sitt långa uppehåll. Han har hittills gjort 14 starter (1-6-2) och travade rekordet 1.12,1ak i finalen av Jarlsberg Grand Prix.</p>



<p>Han ställs mot en annan häst som gör intressant comeback. Per Linderoth har höga tankar om<strong> Invisible Sun </strong>(e. Ready Cash), som förra sommaren vann klass I-försök i Linderoths regi och visade hög kapacitet med fem segrar på 14 starter.</p>



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



<p class="has-drop-cap">3Fredagsgiven inleds till lunch i Kalmar (första start 12.20) med nio lopp på menyn. Banans fyraåringsserie drar igång med första försöket av fem och final i Kalmar den 22 november med 150.000 kronor till vinnaren. Förra årets final låg en månad tidigare i kalendern och då segrade hemmastjärnan A Fair Day (e. Maharajah), innan han gick vidare och vann semifinal och final i Breeders Crown.</p>



<p>Om någon av deltagarna i första försöket kan nå fjolårsvinnarens höjder återstår att se, men Johan Untersteiner har en god fyraåring i <strong>Global Eminent </strong>(e. Southwind Frank), som inlett tävlingskarriären först i år. Detta med två segrar och två tredjeplatser som resultat och nu jagas tredje triumfen från springspår.</p>



<p>Hemmatränaren Fredrik Persson hade kunnat plocka ut sitt fyraåriga sto <strong>Janita Silvio </strong>(e. Father Patrick) i fyraåringsserien, men då från 40 meters tillägg. Istället väljer han att möta äldre hästar i ett vanligt lopp där hon står perfekt inne på pengarna med fjolårets finalist i Breeders Crown för treåriga ston.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/04/240419.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/janitasilvioheat-617x333.jpg" alt="" class="wp-image-523518"/><figcaption class="wp-element-caption">Janita Silvio och Fredrik Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">4Starta eller inte starta? I franska förbundets officiella startlistor står alltjämt Tomas Malmqvists <strong>Isla Jet </strong>(e. Bold Eagle) kvar som startande i kvällens Prix Aletheia (€90.000) som körs på Vincennes (första start kl. 16.03).</p>



<p>Franck Nivard är uppsatt som kusk bakom stoet som tar strid med vintermeetingstoppar som <strong>Ibiki de Houelle</strong> (e. Love You) och <strong>Ino du Lupin</strong> (e. Scipion du Goutier).</p>



<p>Tävlingsdagens svensktätaste loppet är dock ett annat. I Prix Martha (€46.000) för sex- och sjuåriga hästar som högst tjänat 125.000 euro tävlar en blågul trio utöver den svenskägde <strong>Bitcoind&#8217;Arc</strong> (e. Voltigeur de Myrt) som finns i Erik Bondos regi.<br>Christoffer Eriksson bidrar med<strong> Django Silver </strong>(e. Django Riff), Dominik Locqueneux med <strong>Halo Am</strong> (e. Father Patrick) och Daniel Wäjersten med <strong>Chitchat</strong> (e. Maharajah) som körs av Björn Goop.</p>



<p>I fyraåringsloppet Prix Lumen (€35.000) är Goops egentränade <strong>Keep Out </strong>(e. Dijon) därtill på ny segerjakt. Hingsten har inlett karriären med tre raka segrar och är obesegrad inför dagens lopp.</p>



<p>Andra sportsliga höjdpunkter under kvällen är montéstjärnan <strong>Granvillaise Bleue </strong>(e. Jag de Bellouet) som tävlar i Prix Theophile Lallouet (€120.000) och så kommer Prix d&#8217;Amerique-vinnare Belina Josselyns förstfödda dotter<strong> Liza Josselyn</strong> (e. Ready Cash) ut i Prix Aschera (€70.000) där hon ska försöka bärga karriärens andra Grupp III-seger.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-04-19/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">5Goop börjar dock sin arbetsdag på annat håll i Frankrike denna fredag. Först av allt beger han sig nämligen till Amiens (första start kl. 11.35) knappt 16 mil norr om Paris för att försöka få tillbaka egentränade <strong>Kezio Josselyn</strong> (e. Brillantissime) på rätt köl efter tre raka galopper. Hästen startar i Prix Maurice de Folleville (€17.500) klockan 13.42 och Goops första styrning i den franska huvudstaden tävlar först klockan 18.32.</p>



<p>Två svenska hästar tävlar därtill i Prix de Mondonville (€25.000) på högervarvsbanan i Toulouse (första start kl. 18.50).<br>Tomas Malmqvists <strong>M.T.Oscar </strong>(e. Yarrah Boko) är alltjämt inte struken ur det loppet och så ska även svenskfödde exporten <strong>Testa di Cavolo </strong>(e. Un Mec d&#8217;Heripre) försöka freda sig startande 25 meter före.</p>



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



<p class="has-drop-cap">6Den finländske tränaren Hannu Korpi har köpt äldre, svenska hästar på löpande band de senaste åren och inte sällan med gott resultat.</p>



<p><strong>Hierro Boko</strong> (e. From Above) är tveklöst den starkast lysande stjärnan, men nu tycks även åttaårige <strong>Upper Face </strong>(e. Trixton) vara på väg att lyfta.</p>



<p>Under onsdagskvällen vann hästen ett montélopp på Vermo på 1.13,5a/1.620 meter vilket utöver förstapriset på 3.000 euro även gav startberättigande i montéloppet Prix Finlandia Ajo under just Finlandia Ajo-dagen där det rids om 8.000 euro till vinnaren.</p>



<p>Dessförinnan hinner dock Upper Face med – minst – en start till. Redan i morgon är han tillbaka på tävlingsbanan då hästen tävlar i ett V75-lopp i finska Seinäjoki där vinnaren belönas med 10.000 euro. Det blir Upper Face tionde start bara under år 2024!</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/upperface-617x333.jpg" alt="" class="wp-image-454408"/><figcaption class="wp-element-caption">Upper Face. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">7Två svenskfödda hästar utgör dagens deltagarskara i Road To Lotteria (€13.200) på Agnano-banan i Neapel.</p>



<p>Alessandro Gocciadoros <strong>Bythebook</strong> (e. Googoo Gaagaa) jagar sin första årsseger i vad som blir årets femte framträdande och så syns Giorgio d&#8217;Alessandro Sr:s <strong>Tyrion</strong> (e. Trixton) startande från innerspår.</p>



<p>Vinnaren belönas med 5.520 euro samt en av de 24 platserna i Gran Premio della Lotteria (€660.000) som avgörs på samma bana onsdag den 1 maj.</p>



<p><strong>Startlista</strong><br><em>1.600 meter autostart</em></p>



<ol class="wp-block-list">
<li>Tyrion – Giorgio d&#8217;Alessandro Sr</li>



<li>Bythebook – Alessandro Gocciadoro</li>



<li>Zefiro d&#8217;Ete – Gaetano di Nardo</li>



<li>Back On Top – Francesco Tufano</li>



<li>Fiorano – Roberto Vecchione</li>



<li>Dali Prav – Rene&#8217; Legati</li>



<li>Diva del Ronco – Mario Minopoli Jr</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
”Ett djävulskt lopp”
Om unghästtoppar som drabbar samman på Romme, Björn Goops segerjakt på dubbla banor i Frankrike samt två svenskfödda hästar som jagar biljett till "Lotterian" går bland annat att läsa om i veckans femte morgonsvep.
