
<p class="has-drop-cap">1 Criterium des Jeunes (€200.000) står i centrum idag för treåringar och 14 hästar gör upp om förstapriset på 90.000 euro över distansen 2.700 meter.</p>



<p>Favorit till segern är Nicolas Bazires <strong>Mille Etoiles</strong> (e. Prodigious) 1.14,5m*/€89.565, och hon körs av Jean-Michel Bazire. Tre raka segrar har stoet vunnit på den franska huvudstadsovalen på lika många starter under 2025. Hon utmanas i första hand av trion <strong>Maitre Jaques</strong>, <strong>Maestro River </strong>och <strong>Mack de Blary</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/prixdetignes1-617x415.jpg" alt="" class="wp-image-687710"/><figcaption class="wp-element-caption">Mille Etoiles och Jean-Michel Bazire. Foto: Gerard Forni</figcaption></figure>



<p>Senast Jean-Michel Bazire toppade i Criterium des Jeunes var 2020 och även då bakom ett sto – <strong>Havana d’Aurcy</strong> (e. Royal Dream) – och han har också vunnit med hingsten <strong>Coquin Bebe</strong> (e. Rancho Gede) 2015.</p>



<p><strong>Criterium des Jeunes</strong> (€200.000)<br>Treåringar.<br><strong>Priser: </strong>90.000-50.000-28.000-16.000-10.000-4.000-2.000 euro.<br><em>2.700 meter.</em></p>



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



<ol class="wp-block-list">
<li><strong>Monegasque </strong>(e. Goetmals Wood) – Gabriele Gelormini/Jean-Michel Baudouin</li>



<li><strong>Masina de Tillard</strong> (e. Face Time Bourbon) – Clément Duvaldestin/Thierry Duvaldestin</li>



<li><strong>Machucambo</strong> (e. Ready Cash) – Mathieu MottierAlexis Philippe Grimault</li>



<li><strong>Missandei </strong>(e. Village Mystic) – Benjamin Rochard/Antonio Ripoll Rigo</li>



<li><strong>Margeaux des Arris</strong> (e. Carat Williams) – David Thomain/Vincent Lebarque</li>



<li><strong>Mat Manathis </strong>(e. Booster Winner) – Alexis Prat</li>



<li><strong>Maitre Jacques </strong>(e. Rolling d’Heripre) – Alexandre Abrivard/Laurent-Claude Abrivard</li>



<li><strong>Misty Green</strong> (e. Love You) – William Bigeon</li>



<li><strong>Maestro River </strong>(e. Galius) – Eric Raffin/Sébastien Guarato</li>



<li><strong>Mille Etoiles </strong>(e. Prodigious) – Jean-Michel Bazire/Nicolas Bazire</li>



<li><strong>Moraility</strong> (e. Rocklyn) – Julien Dubois</li>



<li><strong>Magnum du Choquel </strong>(e. Hohneck) – Francois Lagadeuc/Nicolas Bridault</li>



<li><strong>Monzon Normand </strong>(e. Hohneck) – Yoann Lebourgeois/Philippe Allaire</li>



<li><strong>Mack de Blary</strong> (e. Face Time Bourbon) – Théo Duvaldestin/Thierry Duvaldestin</li>
</ol>



<p><a href="https://sulkysport.se/sjatte-segern-for-allaire/" data-type="link" data-id="https://sulkysport.se/sjatte-segern-for-allaire/" target="_blank" rel="noreferrer noopener">Här kan du läsa mer om Criterium des Jeunes. </a></p>



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



<p class="has-drop-cap">2 Även om det inte syns några svensktränade hästar i Criterium des Jeunes så startar åtta svenskfödda travare på Vincennes (första start kl. 13.23) idag och bara en tränas av en blågul tränare; Jörgen Westholms <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) som jagar andra raka segern tillsammans med Alexandre Abrivard.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/00255317014scoopdyga-617x411.jpg" alt="" class="wp-image-623668"/><figcaption class="wp-element-caption">Ninepoints Lasse har gjort succé i Frankrike. Blir det en ny triumf idag? Foto: Scoopdyga</figcaption></figure>



<p><strong>Prix de Lannon (€40.000) – 2.700 meter</strong><br><em>– <strong>Orazi Cesare</strong> (e. Feliciano) – Mathieu Mottier<br>– <strong>Odyssey Boko</strong> (e. E L Titan) – Matthieu Abrivard</em></p>



<p><strong>Prix de la Gacilly (€46.000) – 2.850 meter</strong><br><em>– <strong>Sangria Pellini </strong>(e. Chocolatier) – Matthieu Abrivard<br>– <strong>Junkie</strong> (e. Varenne) – Thomas Levesque</em></p>



<p><strong>Prix de Grenade (€59.000) – 2.700 meter, monté</strong><br><em>– <strong>Huis Clos</strong> (e. Bird Parker) – Alexandre Abrivard<br>– <strong>Alone</strong> (e. Maharajah) – Alexis Collette</em></p>



<p><strong>Prix d’Arras </strong>(€59.000) – 2.700 meter<br>– <strong>L.A. Boko</strong> (e. Readly Express) – Björn Goop<br>– <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) – Alexandre Abrivard</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-02-16/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-02-16/" target="_blank" rel="noreferrer noopener">Startlistorna till Vincennes tävlingar hittar ni här.</a></p>



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



<p class="has-drop-cap">3 Igår drog avelssäsongen officiellt igång i Frankrike och runt 300 hingstar kommer tjänstgöra under 2025, varav ett 30-tal nykomlingar. Avelssäsongen pågår mellan den 15 februari och 15 juli.</p>



<p>Allra flest hingstar finns uppstallade i Normandie, men den mest omdiskuterade finns i USA och <strong>Tactical Landing</strong> kommer att nyttjas till 60 franska stoägare med fryst sperma, vars uppenbarelse har både tagits emot med öppna armar och burop.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/08/prixjockey226-617x396.jpg" alt="" class="wp-image-628565" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Jushua Tree kostar mest att betäcka med av de nya avelshingstarna i Frankrike.  Foto: Gerard Forni</figcaption></figure>



<p>1.650 ston anmäldes till betäckning med Tactial Landing och 60 fick plats. Även om det finns motsättningar att Muscle Hill-sonen används i fransk avel så har det franska jordbruksministeriet givit grönt ljus för Tactical Landing och att hans avkommor blir registrerade som franskfödda i stamboken Livre Généalogique du TrotteurFrançais.</p>



<p>Nedan hittar ni de nya avelshingstarna som kostar 5.000 euro eller mer att betäcka med under 2025:</p>



<h2 class="wp-block-heading">Namn (far) – Pris (€)</h2>



<ul class="wp-block-list">
<li><strong>Jushua Tree </strong>(e. Bold Eagle) – 15.000</li>



<li><strong>King Opera </strong>(e. Ready Cash) – 10.000</li>



<li><strong>Kobayashi </strong>(e. Face Time Bourbon) – 10.000</li>



<li><strong>Keenan de Joudes</strong> (e. Ready Cash) – 7.000</li>



<li><strong>Khal’s Fella </strong>(e. Ready Cash) – 6.500</li>



<li><strong>Lombok Jiel</strong> (e. Enino du Pommereux) – 5.800</li>



<li><strong>Josh Power </strong>(e. Offshore Dream) – 5.500</li>



<li><strong>Lovino Bello</strong> (e. Village Mystic) – 5.000</li>
</ul>



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



<p class="has-drop-cap">4Nästnästa lördag – den 1 mars. Då delar Elitloppsgeneralen Anders Malmrot ut den första biljetten till Elitloppet 2025! <br>– Det känns jättebra och det är stort intresse för Elitloppet. På Elitloppslistan tickar det in namn hela tiden, så jag får en diger uppgift att avgöra form och annat, sade Anders Malmrot till V65 Direkt. </p>



<p>Han har gjort flera resor till Frankrike i vinter och upplever en skillnad mot tidigare. <br>– Det är jätteroligt att det vänt och fransmännen kommer till mig och vill vara med istället för tvärtom. Som det ser ut nu kommer det att bli en jämn fördelning mellan Sverige och Frankrike när det gäller antalet deltagare från de båda länderna, sade Malmrot.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/6idaodetillardmalgang-617x333.jpg" alt="" class="wp-image-588666"/><figcaption class="wp-element-caption">Idao de Tillard slutade sexa i Elitloppsförsöket ifjol efter tidig galopp. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Förra året delade Malmrot ut första biljetten den 24 februari – till Prix d’Amérique-vinnaren <strong>Idao de Tillard</strong>.<br>Totalt ska 13 biljetter delas ut, medan det tävlas om övriga tre platser på Solvalla, Gävle och Vermo.</p>



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



<p class="has-drop-cap">5Travveckan avslutas i <strong>Eskilstuna </strong>(start 13.45), där det är jackpot på Grand Slam 75-spelet. 1,1 miljoner kronor extra ligger i både sju- och femrättspotten, medan hälften finns för sexorna.</p>



<p>Efter dubbla, långa sejourer på fransk mark i regi Björn Goop (en seger på 17 starter) gick kapable <strong>Gaylord Am</strong> (e. Muscle Hill) i träning till Timo Nurmos när han vände hem till Sverige igen i början av förra sommaren.<br>Efter drygt fyra månader hos Nurmos blev det seger direkt i comebacken i mitten av oktober. Början på en framgångsrik period? Nej, två veckor senare ströks han från en tilltänkt start på Solvalla och sedan dess har han varit borta från tävlingsbanan.</p>



<p>Idag är han tillbaka, från 60 meters tillägg i ett långlopp och Magnus A Djuse hoppar upp i vagnen för första gången. Gaylord Am ställs mot blott sju konkurrenter i kamp om förstapriset på 35.000 kronor.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/02/16gs75.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">6 För första gången sedan 1891 tillåts en utvidgning av spelutbudet för hästkapplöpningsindustrin. I torsdags godkände det franska författningsrådet möjlighet till live-spel, men också att ingå vad på cirka 150.000 historiska lopp och detta efter många månaders lobbyarbete från både travets och galoppens sida.</p>



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



<p class="has-drop-cap">7 Italienske Derbyvinnaren First of Mind galopperade bort sig I sista sväng och det öppnade upp för <strong>Fortunadrago Font </strong>(e. Quite Easy-Onice Font) och Enrico Bellei i Gran Premio Firenze (€66.000) igår i Florens.</p>



<p>First of Mind och Alessandro Gocciadoro övertog täten varvet före mål och i samma veva blev det andra utvändigt för Fortunadrago Font  och Enrico Bellei.</p>



<p>Duon kastade loss i tredjespår 600 kvar, tog sig snabbt fram i dödens, men det blev ingen match mot storfavoriten First of Mind sedan han galopperat bort sina chanser 450 meter före mål.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/skarmavbild20250216kl.08.34.16-617x325.jpg" alt="" class="wp-image-687788"/><figcaption class="wp-element-caption">Fortunadrago Font  och Enrico Bellei.</figcaption></figure>



<p>Istället gick 27-oddsaren Fortunadrago Font enkelt undan till seger i Grupp II-loppet för fyraåringar på 1.13,5a/2.020 meter. Far West Bi (e. Muscle Hill) var tvåa på 1.13,8 och tredjeplatsen tog Finalmente Par (e. Varenne) på 1.14,4.</p>



<p>Fortunadrago Font har tidigare vunnit Gran Premio Gaetano Stabile, men också slutat trea i Gran Premio Citta di Napoli och samma placering noterades i finalen i Gran Premio Orsi Mangelli sedan måltrean Lovino Bello diskats för doping.</p>



<p>Modern <strong>Onice Font</strong> (e. Coktail Jet), 1.13,4*/€69.354, ingår i samma syskonskara som Coppa Allevamento Filly-vinnaren <strong>Conversa Sm</strong> (e. Lemon Dra), 1.13,1/€165.114, och Oaks del Trotto-femman <strong>Miss Slid Font Sm</strong> (e. Yankee Slide), 1.13,3/€38.365.</p>



<p>Ostartade mormor <strong>Verita’ Lavec</strong> (e. Beseiged-Kramer Samba) är halvsyster med Jimmy Takters storstjärna och avelshingst <strong>Mr Lavec</strong> (e. Speedy Somolli), 1.11,0ak/13.473.915 kr.</p>



<p><a href="http://webtv.awsteleippica.com/videos/6368881901112" data-type="link" data-id="http://webtv.awsteleippica.com/videos/6368881901112" target="_blank" rel="noreferrer noopener">Se loppet här.</a></p>
