
<p class="has-drop-cap">1 Prix de France (€400.000) står i centrum idag och Daniel Redén har två hästar till start i medeldistans loppet på <strong>Vincennes </strong>(första start kl. 13.23) med 180.000 euro till vinnaren. Så här uttalar sig Redén om chanserna på stallets hemsida:</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/francescozetdr260125adamstromstalltz-617x381.jpg" alt="" class="wp-image-817550"/><figcaption class="wp-element-caption">Francesco Zet och Daniel Redén. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>– <strong>Francesco Zet </strong>spurtade strålande i Prix d’Amérique och trivs verkligen som fisken i vattnet på Grosbois. Jag körde honom i måndags och intervaller i torsdags och han känns mycket bra. Spåret är lite lurigt men det får Benjamin Rochard lösa. Barfota runt om igen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/epickronosdrh260125adamstromstalltz-617x385.jpg" alt="" class="wp-image-817551"/><figcaption class="wp-element-caption">Epic Kronos. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>– <strong>Epic Kronos</strong> gjorde ett starkt Prix d’Amérique utan att kanske vara helt på topp. Kan ha varit resorna som slet lite. Nu ser han fin ut igen och samma balans som senast.</p>



<p>Mattias Djuse startar också danske Derbyvinnaren <strong>Icebreaker </strong>(e. Chocolatier), men han är ute på djupt vatten.</p>



<p><strong>Prix de France</strong> (€400.000)<br>4-11 år.<br><strong>Priser: </strong>180.000-100.000-56.000-32.000-20.000-8.000-4.000 euro<br><em>2.100 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Francesco Zet</strong> (e. Father Patrick) – Benjamin Rochard/Daniel Redén</li>



<li><strong>Inmarosa </strong>(e. Amiral Sacha) – Léo Abrivard/Laurent-Claude Abrivard</li>



<li><strong>Iguski Sautonne </strong>(e. Village Mystic) – Matthieu Abrivard</li>



<li><strong>Epic Kronos</strong> (e. Muscle Hill) – Alexandre Abrivard/Daniel Redén</li>



<li><strong>Go On Boy</strong> (e. Password) – Romain Derieux</li>



<li><strong>Hokkaido Jiel </strong>(e. Brillantissime) – Franck Nivard/Jean-Luc Dersoir</li>



<li><strong>Keep Going</strong> (e. Follow You) – Mathieu Mottier</li>



<li><strong>Executiv Ek</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Josh Power </strong>(e. Offshore Dream) – David Thomain/Sébastien Ernault</li>



<li><strong>Iroise de la Noe</strong> (e. Tornado Bello) – Thomas Levesque</li>



<li><strong>Idole d’Ourville </strong>(e. Booster Winner) – Robin Lamy/Emmanuel Varin</li>



<li><strong>Rikita J.P. </strong>(e. Mister J.P.) – Corentin Delbecq/Jocelyn Robert</li>



<li><strong>Icebreaker </strong>(e. Chocolatier) – Gabriele Gelormini/Mattias Djuse</li>
</ol>



<p><a href="https://sulkysport.se/tva-chanser-till-blagul-seger/" data-type="link" data-id="https://sulkysport.se/tva-chanser-till-blagul-seger/" target="_blank" rel="noreferrer noopener">Här kan du läsa mer om Prix de France och loppets historia.</a></p>



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



<p class="has-drop-cap">2 Vincennes söndagstävlingar bjuder på mer blågult. I Prix de Rouen (€90.000) över 2.850 meter startar fyra svenskfödda travare; Björn Goops <strong>Underground Artist </strong>(e. Royalty For Life), Simon Rousselles <strong>Pantocrator </strong>(e. Quarcio du Chene), Johan Untersteiners <strong>Boscha Diablo</strong> (e. Traders) och Daniel Wäjerstens <strong>Kuiper </strong>(e. Face Time Bourbon).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/12/scoopdyga123089020-617x410.jpg" alt="" class="wp-image-803058"/><figcaption class="wp-element-caption">Kuiper spurtar ytterst till vinst för Daniel Wäjersten. Foto: Scoopdyga</figcaption></figure>



<p>Distansen är 2.850 meter och förstapriset är 40.500 euro i loppet som är öppet för europafödda sexåringar.</p>



<p>Det hålls också två semi-classique-löpningar – Prix Ovide Moulinet (€120.000) för femåringar och Prix Louis Le Bourg (€120.000) för fyraåringar under sadel – på Vincennes <a href="https://www.letrot.com/courses/programme/2026-02-08/7500" data-type="link" data-id="https://www.letrot.com/courses/programme/2026-02-08/7500" target="_blank" rel="noreferrer noopener">och startlistorna hittar ni här.</a></p>



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



<p class="has-drop-cap">3 Gävle (första start 13.45) är enda svenska bana som tävlar denna söndag och det bjuds goda tävlingar med en hel del hästar som firat framgångar i vinter.</p>



<p>Som duon <strong>Charming Laura</strong> (e. Northern Charm) och <strong>Pete Baldwin</strong> (e. Who’s Who). Sybille Tinter-tränade Charming Laura kommer från två januarisegrar, medan Peter Baldwin avslutade 2025 med vinst på V85:s uppesittarkväll i Örebro och inledde det nya året med triumf i Mantorp.<br>Då tränades Pete Baldwin av Axevallas Thomas Dalborg, men på Traveras auktion den 10 januari butte hästen ägare när italienska Agrinvestment Soc. Agr. SRL klickade hem hästen för 150.000 kronor.</p>



<p>Sedan några veckor tillbaka finns Pete Baldwin i träning hos Solvallaamatören Liselotte Olsson och i regidebuten idag sitter Joseph Taavela Ruocco i vagnen. Liselotte har 15 hästar på träningslistan och förra året sprang hennes travare in 660.400 kronor på drygt 100 starter.<br>Största segern de senaste säsongerna kom i Rättviks V75-omgång i augusti 2023, då <strong>Izola Silvåkra</strong> (e. Zola Boko) vann ett försök i diamantstoet tillsammans med Niclas Hammarström.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/02/08gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 I storstjärnan Keayang Zaharas frånvaro tog <strong>Jilliby Ballerini </strong>(e. Majestic Son-Shesasundon) hem Kilmore Trotters Cup ($75.000) igår i Kilmore. Jason Lee vann bakom favoritspelade Jilliby Ballerini och bakom henne slutade stallkamraten Jilliby Dreamlover (e. Love You) tvåa.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/jillibyballerinipic030126-617x464.jpg" alt="" class="wp-image-817569"/><figcaption class="wp-element-caption">Jilliby Ballerini. Foto: Hrv</figcaption></figure>



<p>Vinnartiden skrevs till 1.13,2a/2.180 meter och det var karriärens 15:e seger på 30 starter. Gårdagens triumf var den fjärde raka triumfen och Jilliby Ballerini har undvikit att möta Keayang Zahara sedan hon fick stryk mot henne den 18 oktober förra året i Bill Collins Trotters Sprint ($60.000) på Melton.</p>



<p>Nästa helg – när försök och final avgörs i Great Southern Stars ($250.000) – lär de båda stona mötas igen.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260207kl.08.18.40-617x310.jpg" alt="" class="wp-image-817560"/><figcaption class="wp-element-caption">Det var ingen större publikfest och få som ville hylla Ronnie Wrenn Jr. Foto: Chris Gooden Photo</figcaption></figure>



<p class="has-drop-cap">5 Den amerikanske kusken <strong>Ronnie Wrenn Jr. </strong>skrev under torsdagseftermiddagen in sig i historieböckerna. Vid tävlingarna på Meadows nådde 39-åringen den imponerande milstolpen 9.000 segrar.</p>



<p>Ronnie Wrenn Jr. klev in i tävlingsdagen med 8.997 segrar i bagaget och behövde därmed en trio vinnare för att nå den magiska gränsen. Han inledde starkt genom att vinna två av de fyra första loppen. I det sjätte lopp var det dags för jubileumssegern.</p>



<p><strong>Green Meadow </strong>(e. Greenshoe-Christiana Hanover) blev hans jubileumshäst och från ledningen blev det seger med nos på 1.13,6/1.609 meter. Wrenn Jr. nöjde sig med tre vinster under dagen utan vann ytterligare två lopp.</p>



<p>Förra året körde han in rekordhöga 12.594.657 dollar och sitt bästa år som kusk (segrar) hade han 2014 med 847 triumfer. Sedan 2013 har han vunnit minst 500 lopp varje år.</p>



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



<p class="has-drop-cap">6 <strong>Courtney Hall</strong> (e. Garland Lobell-Canne Angus), 1.10,9/$118.986, har gått ur tiden och stoet avled efter komplikationer i samband med fölning den 29 januari och blev 24 år.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/courtneyhall082205newimagemedia1024px-617x347.jpeg" alt="" class="wp-image-817556"/><figcaption class="wp-element-caption">Courtney Hall. Foto: New Image Media</figcaption></figure>



<p>Hennes tävlingskarriär innehöll sex vinster på 19 starter och bland annat vann hon en division av Bluegrass Stakes ($93.100) under Anders Lundström Woldens vingar.</p>



<p>Stamtavlan är av högsta klass; helsyster till dubbelmiljonären <strong>Cameron Hall</strong> och <strong>Canland Hall</strong> – den sistnämnda mest känd som mor till avelsgiganten <strong>Cantab Hall</strong>.</p>



<p>Courtney Halls avkommor tjänade över tre miljoner dollar och toppar gör <strong>El Ideal </strong>($830.857) och han följs av <strong>E L Titan </strong>($702.473), <strong>Appomattox</strong> ($619.895), <strong>E L Rock </strong>($378.265), <strong>E L Rocket</strong> ($241.310) och <strong>El Nightwish </strong>($134.527).</p>



<p>Totalt fick Courtney Hall 14 avkommor och hennes sista föl föddes i år – en hingst efter <strong>Green Manalishi</strong> – och han uppges må bra och har fått en ammasto på Blue Chip Farms i staten New York.</p>



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



<p class="has-drop-cap">7 San Siro i Milano bjuder på Grupp III-löpningen Gran Premio Mario Locatelli (€25.300) för äldre travare. Sabato Bevilacqua-tränade <strong>Ontario </strong>(e. Muscle Mass-Gillarney F. Boko) är obesegrad i två starter på italiensk mark</p>



<p>Vid en av segrarna satt Gaetano di Nardo i sulkyn och han får också chansen på söndag bakom det femåriga svenskfödda stoet som tidigare tränades av Maria Törnqvist.</p>



<p><strong>Gran Premio Mario Locatelli</strong> (€25.300)<br>Fyraåriga och äldre travare.<br><em>2.120 meter.</em></p>



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



<ol class="wp-block-list">
<li><strong>Dolly Effe </strong>(e. Mago d’Amore) – Riccardo Pezzatini</li>



<li><strong>Fakir Roc </strong>(e. Wishing Stone) – Santo Mollo</li>



<li><strong>Cienfuegos Laumar</strong> (e. Ganymede) – Rene’ Legati</li>



<li><strong>Chemar </strong>(e. S.J.’s Photo) – Massimo Castaldo</li>



<li><strong>Ontario</strong> (e. Muscle Mass) – Gaetano di Nardo</li>



<li><strong>Farlow Selva</strong> (e. Ringostarr Treb) – Manuel Galeazzi</li>



<li><strong>Dilettevole Nap</strong> (e. Nesta Effe) – Giorgio Alessandro Jr.</li>



<li><strong>Cherry Top</strong> (e. Igor Font) – Francesco Tufane</li>



<li><strong>Esterel Gi</strong> (e. Vivid Wise As) – Andrea Guzzinati</li>



<li><strong>Brezza du Kras</strong> (e. Irving Rivarco) – Gennaro Riccio<br><em>– 2.140 meter:</em></li>



<li><strong>Funky Roc </strong>(e. Nad al Sheba) – Filippo Rocca</li>



<li><strong>Diana Pizz</strong> (e. No Reply) – Maurizio Cheli</li>



<li><strong>Fil Ek</strong> (e. Ringostarr Treb) – Pietro Gubellini</li>



<li><strong>Fantastic Gio </strong>(e. Face Time Bourbon) – Federico Esposito</li>



<li><strong>Follia d’Esi</strong> (e. Ringostarr Treb) – Marco Stefani</li>
</ol>
