
<p class="has-drop-cap">1Björn Goop-tränade stoet<strong> Betting Pacer </strong>(e. Maharajah) slog till med seger på Solvalla i mitten av februari på 1.11,5a/1.640 meter – årets snabbaste tid på svensk mark. Den tangerades av italienaren <strong>Danao Degli Dei </strong>(e.  Mago d’Amore) och Adrian Kolgjini i silverdivisionen i Örebro förra lördagen.</p>



<p>I eftermiddag talar mycket för att det blir en ny ”season leader”. Gulddivisionen i Halmstad (första start 14.45) är utskriven över sprinterdistans med startbil och även om väderleksrapporten säger lite regn på förmiddagen torde det gå undan med sju av tio deltagare helt utan skor under hovarna.</p>



<p>En av dessa är hemmatränaren Håkan K Perssons snabbloppare <strong>Four Guys Dream</strong> (e. Dream Vacation), som vann gulddivisionen på Jägersro i fjolårets sista start barfota runt om. I vinter har han med skor resultaten 5-d-5 i tre starter i högsta klassen.<br>– <em>Jag vet inte riktigt hur formen är. Han känns jättefin i träning och har gjort hela vintern utan att få utdelning. Nu tävlar han optimalt och som han gått när han varit som bäst. André (Eklundh) får prova rejäl från början, men det är många snabba invändigt. Om han kommer till ledningen är det en stor fördel, men det viktigaste är att han får vara med där framme. Jag är jättenöjd om han gör ett fint lopp, jag tror att han gör det, men vill se det först</em>, sade Håkan K Persson till V65 Direkt.</p>



<p>Snabbast 2024 bland dagens guldhästar är Lars I Nilsson-tränade startkatapulten <strong>Sweetman</strong> (e. Gift Kronos), som vann på 1.11,6a/1.640 meter på Jägersro i sin senaste start.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/02/02v75.pdf" class="">Här kan du ta del av startlistor till tävlingarna i Halmstad.</a></p>



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



<p class="has-drop-cap">2Från skotvång till barfotabalans. Igår ritades svenska travkartan om för säsongen när barfotakörning åter blev tillåtet efter vinterns förbud. Sulkysports tipsexpert lutar sig mot två barfotahästar när han plitar ned lördagens bästa singelstreck på V75.</p>



<p>En av spikarna är Ulf Stenströmer-tränade <strong>Utah Southwind</strong> (e. Bold Eagle), som anlände till Axevallatränaren från Frode Hamres stall i november.</p>



<p>”I avslutningen tror vi att lägesgynnade Utah Southwind (V75-7) spårar från start till mål. Ulf Stenströmer har fått flera nyförvärv att lyfta denna vinter och denna häst är kanske det tydligaste exemplet av alla”, <a href="https://sulkysport.se/spelstugan/v75-tips-halmstad-2-mars/" target="_blank" rel="noreferrer noopener">skriver Sulkysports tipster.</a><br>– <em>Hästen kom i fint skick från Norge och har trivts väldigt fint hos oss. Han har fått väldigt självförtroende och tycker att han är kung på gården. Han har gjort fyra riktigt fina lopp i vår regi och jag hoppas det fortsätter. Spår ett känns bra och han är startsnabb. Det blir barfota runt om och bike till 99 procents säkerhet, jag hade tänkt spara det till finalerna, men när han fick det här läget kör vi så redan nu</em>, sade Ulf Stenströmer till V65 Direkt.</p>



<p>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-03-02_18_5" class="">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-03-02_18_5" class="">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



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



<p class="has-drop-cap">3Elitloppsinbjudne Prix d&#8217;Amerique-vinnaren <strong>Idao de Tillard </strong>(e. Severino) gör idag sin sista start för detta vintermeeting när det är finaldag på Vincennes.</p>



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



<p>Prix de Selection (€240.000) för fyra- till sexåriga hästar är uppgiften och Thierry Duvaldestins stjärna vann samma lopp redan som fyraåring då han inledde från startvolten.</p>



<p>Idag är han en av fyra hästar som jagar de fem fyraåringar som startar från grunddistansen 2.175 meter och på Idao de Tillards volt syns även Tomas Malmqvists stostjärna <strong>Jazzy Perrine</strong> (e. Django Riff).</p>



<p><strong>Startlista Prix de Selection</strong><br><em>2.175 meter voltstart, förstapris: 108.000 euro</em></p>



<p><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Keenan de Joudes </strong>(e. Ready Cash) – Jean-Philippe Monclin</li>



<li><strong>Karlito </strong>(e. Ready Cash) – Yoann Lebourgeois/Jean-Philippe Monclin</li>



<li><strong>Kyrielle </strong>(e. Enino du Pommereux) – William Bigeon</li>



<li><strong>Ksar </strong>(e. Follow You) – Matthieu Abrivard/Emmanuel Varin</li>



<li><strong>Kana de Beylev</strong> (e. Express Jet) – Benjamin Rochard/William Bigeon<br><em>2.200 meter:</em></li>



<li><strong>Jag Stryck</strong> (e. Bretigny) – Francois Lagadeuc/Cyrielle Buhigne</li>



<li><strong>J’Aime le Foot </strong>(e. Boccador de Simm) – David Thomain/Antoine Lherete</li>



<li><strong>Jazzy Perrine </strong>(e. Django Riff) – Eric Raffin/Tomas Malmqvist</li>



<li><strong>Idao de Tillard </strong>(e. Severino) – Clément Duvaldestin/Thierry Duvaldestin</li>
</ol>



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



<p class="has-drop-cap">4Det avgörs ytterligare två Grupp I-lopp utöver Prix de Selection (€240.000) på Vincennes (första start kl. 13.23) när banan kör sin sista tävlingsdag för detta vintermeeting.</p>



<p>Det handlar om två montélopp varav Prix des Cantaures (€240.000) har identisk proposition med Prix de Selection bortsett från det faktum att deltagarna bär just sadel.</p>



<p><strong>Jean Balthazar</strong> (e. Alto de Viette) förväntas få bära på favoritskapet i det loppet och i Prix Henri Desmontils (€240.000) för den äldre eliten gör<strong> Esperanza Idole</strong> (e. Quido du Goutier) sin första start sedan segern i Prix de Cornulier (€700.000).</p>



<p>Grupp III-klassade Prix du Plateau de Gravelle (€90.000) för hästar som högst tjänat 755.000 euro innehåller flera spännande namn. Daniel Wäjersten är själv på plats för att köra<strong> Dear Friend</strong> (e. Orlando Vici), Elitloppsdeltagaren <strong>Usain Töll</strong> (e. Googoo Gaagaa) gör sin första start för året och är nu åter hos Gennaro Casillo och så finns fjolårets Grand National du Trot-följetong<strong> Gaspar d’Angis</strong> (e. Quaro) bland deltagarna.</p>



<p>Hästens tränare Jean Michel Baudouin har i dagarna uttryckt nyfikenhet kring att ta sin häst till Solvalla sista helgen i maj och får här en riktigt tuff match då han kliver upp i ringen mot Prix de Luxembourg-utropsteckne<strong>t Face Time</strong> (e. Coktail Jet).</p>



<p>Prix d’Argenton-sur-Creuse (€46.000) för fyraåringar ser dubbla svenskhopp. Tomas Malmqvist tävlar med <strong>Koelho de Nappes</strong> (e. Charly du Noyer) och Alessandro Gocciadoro svingar sig upp bakom egentränade, tillika blågule <strong>Killiam Fromentromentro</strong> (e. Villiam).</p>



<p>Tomas Malmqvist testar lyckan med ytterligare tre hästar på Vincennes. <strong>Kitty Call </strong>(e. Ready Cash) syns i inledningsloppet Prix du Guer-Coetquidan (€52.000) och så tävlar såväl <strong>Keynote</strong> (e. Face Time Bourbon) som <strong>Kobayashi</strong> (e. Face Time Bourbon) i Grupp III-klassade Prix Vindex (€90.000).</p>



<p>Blågul chans finns därtill i Prix de Montsoreau (€68.000) då <strong>Gardner Shaw </strong>(e. Ready Cash) plockas ut av Yannick Henry.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-03-02/">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



<h2 class="wp-block-heading">Så här gick det för de blågula hoppen på Vincennes igår:</h2>



<p><strong>Namn (far) – Tränare – Resultat – Euro</strong></p>



<ul class="wp-block-list">
<li><strong>Isla Jet </strong>(e. Bold Eagle) – Tomas Malmqvist – trea – 10.500 euro</li>



<li><strong>Oscar L.A. </strong>(e. Ready Cash) – Fabrice Souloy – fyra – 6.000 euro</li>



<li><strong>Dollar Doc </strong>(e. Ready Cash) – Jörgen S Eriksson – sjua – 590 euro</li>



<li><strong>G.K.Justus</strong> (e. Brad de Veluwe) – Stefan Arvidsson – sjua – 530 euro</li>



<li><strong>Månskenstösen </strong>(e. Bird Parker) – Björn Goop – diskvalificerad</li>



<li><strong>Nymke Brigadoon </strong>(e. Make It Happen) – Björn Goop – diskvalificerad</li>



<li><strong>Huis Clos</strong> (e. Bird Parker) – Pierre Levesque – diskvalificerad</li>



<li><strong>Grappa Boy</strong> (e. Djali Boko) – Christoffer Eriksson – oplacerad</li>
</ul>



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



<p class="has-drop-cap">5Hannu Korpis svenskfödda fyndköp<strong> Hierro Boko</strong> (e. From Above) hade ett fantastiskt fjolår med segrar i Bergsåker Winter Trot och S:T Michel Ajo. Årsavslutningen blev desto mer ljummen, men säsongen kunde likväl summeras med nio segrar på 24 starter och över tre miljoner svenska kronor i intjänade prispengar.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/hierrobokohannukorpi-617x333.jpg" alt="" class="wp-image-471538"/><figcaption class="wp-element-caption">Hannu Korpis Hierro Boko är redo för ny start. Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Årets säsong har inletts med tre segrar och en andraplats på fyra starter och idag kan han snygga till den statistiken ytterligare då han startar i Gulddivisionens final i finska Tammerfors.</p>



<p>Jorma Kontio har kallats in som kusk bakom tioåringen som drog vinstlotten med spår två bakom startbilsvingen och som passerar en halv miljon euro i intjänade prispengar om han slutar bland de sex främsta.</p>



<p>Bland konkurrenterna syns inte mindre än sex svenskfödda hästar då även <strong>Upper Face</strong> (e. Trixton), <strong>Kurri Jari Boko</strong> (e. Make It Happen), <strong>Claude P.Hill </strong>(e. Yarrah Boko), <strong>Farzad Boko </strong>(e. Zola Boko), <strong>Global Withdrawl</strong> (e. S.J.’s Caviar) och <strong>Com Milton</strong> (e. Raja Mirchi) utgör utmanarskaran.</p>



<p><strong>Startlista</strong><br><em>2.100 meter autostart, förstapris: 10.000 euro</em></p>



<ol class="wp-block-list">
<li>Quite A Lover – Antti Teivainen</li>



<li>Hierro Boko – Jorma Kontio</li>



<li>Jason’s Camden – Hanna Torvinen</li>



<li>Upper Face – Tuomas Pakkanen</li>



<li>Hotshot Luca – Olli Koivunen</li>



<li>Cash Maker – Tapio Perttunen</li>



<li>Kurri Jari Boko – Iikka Nurmonen</li>



<li>Claude P.Hill – Ari Moilanen</li>



<li>Payet – Niko Jokela</li>



<li>Farzad Boko – Antti Ala-Rantala</li>



<li>Global Withdrawl – Santtu Raitala</li>



<li>Com Milton – Tommi Kylliäinen</li>
</ol>



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



<p class="has-drop-cap">6För årstiden ovanligt penningstinna lopp avgörs i norska Jarlsberg (första start kl. 19.15) under lördagskvällen.</p>



<p>Vårt västra grannland har arrangerat Vinterserien under den kalla årstiden med förhöjda prispengar som ska stimulera för tävling även denna tid på året och nu är de framme vid finaldagen.</p>



<p>Det körs tre finaler för såväl varm- som kallblod med 125.000 norska kronor i segerpremie, men det mest namnstarka fältet syns likväl i ett annat lopp.</p>



<p>Champion Elitelöp för varmblodseliten innehåller nämligen fjolårets Elitloppsfinalist tillika Finlandia Ajo-vinnare <strong>Stoletheshow</strong> (e. Dream Vacation) samt 2022 års inhemska derbyvinnare <strong>Charleston Volo</strong> (e. Classic Photo).</p>



<p><strong>Startlista Champion Elitelöp</strong><br><em>2.100 meter autostart, förstapris: 100.000 nok</em></p>



<ol class="wp-block-list">
<li>Charleston Volo – Per Oleg Midtfjeld</li>



<li>Miss Pepper – Åsbjörn Tengsareid</li>



<li>High Glider – Lars Anvar Kolle</li>



<li>Type A. – Magnus Teien Gundersen</li>



<li>Stoletheshow – Frode Hamre</li>



<li>Custom Cheval – Henry Rorgemoen</li>



<li>Always On Time – Tom Erik Solberg</li>
</ol>



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



<p class="has-drop-cap">7Kvällens auktion hos Travera består av 23 nummer och tio av dem är starthästar. Sexåriga stoet <strong>Global Chit Chat </strong>(e. S.J.’s Caviar), 1.11,1ak/430.200 kr, är en av dessa. Hon kvalade in till Stosprintern för 1,5 år sedan (femma i finalen) och gjorde en start på Vincennes i december, där hon dock galopperade bort sig.</p>



<p>Av tio fölston i katalogen är fem dräktiga. Hingstvalen är <strong>Calgary Games</strong>, <strong>Captain Corey</strong>, <strong>Don Fanucci Zet</strong>, <strong>Perfect Spirit </strong>och <strong>San Moteur</strong>. En av de som inte är dräktiga är <strong>Athena Face</strong> (e. Djali Boko), 1.12,0ak/611.500 kr, som är lillasyster till 14-faldige miljonären Mosaique Face.</p>



<p>Ett ettåring, <strong>Downstream</strong> (e. Uncle Lasse), med starkt amerikanskt och fransk möderne bjuds också ut. På hingstsidan säljs en hingstandel i <strong>Trixton</strong>, samt en betäckningsrätt 2024 i <strong>Flocki d’Aurcy</strong>.</p>



<p><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>
