
<p class="has-drop-cap">1 <a href="https://sulkysport.se/prix-de-france-trion-ska-bryta-sviten/" data-type="link" data-id="https://sulkysport.se/prix-de-france-trion-ska-bryta-sviten/" target="_blank" rel="noreferrer noopener">Prix de France</a> (€400.000) avgörs på Vincennes idag över 2.100 meter (autostart) med 180.000 euro till vinnaren och tre svensktränade hästar tar chansen. Daniel Redéns <strong>Don Fanucci Zet</strong> (e. Hard Livin) och Sabine Kagebrants <strong>Kilmister </strong>(e. Chapter Seven) står fortfarande utan seger på den franska huvudstadsovalen, medan Jörgen Westholms <a href="https://sulkysport.se/blir-det-fart/" data-type="link" data-id="https://sulkysport.se/blir-det-fart/" target="_blank" rel="noreferrer noopener">Working Class Hero </a>(e. Village Mystic) har vunnit fyra lopp på Vincennes och senast under Prix d&#8217;Amérique-dagen.</p>



<p>Franska travtidningen Paris-Turf rankar Don Fanucci Zet som tvåa, medan <strong>Go On Boy </strong>(e. Password) är favorit till segern. </p>



<p><strong>Paris-Turfs ranking:</strong> 4-3 (Don Fanucci Zet)-2-12-9-11 (Working Class Hero)-6-7-8-10-1-5 (Kilmister)-13</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>Ampia Mede Sm</strong> (e. Ganymede) – Vincenzo d’Alessandro Jr/Erik Bondo</li>



<li><strong>Emeraude de Bais</strong> (e. Repeat Love) – Franck Nivard/Benjamin Goetz</li>



<li><strong>Don Fanucci Zet </strong>(e. Hard Livin) – Paul-Philippe Ploquin/Daniel Redén</li>



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



<li><strong>Kilmister</strong> (e. Chapter Seven) – Gabriele Gelormini/Sabine Kagebrant</li>



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



<li><strong>Banderas Bi</strong> (e. Ganymede) – Eric Raffin/Alessandro Gocciadoro</li>



<li><strong>Hooker Berry </strong>(e. Booster Winner) – Nicolas Bazire</li>



<li><strong>Hussard du Landret </strong>(e. Bird Parker) – Yoann Lebourgeois/Benoït Robin</li>



<li><strong>Ideal Ligneries </strong>(e. Repeat Love) – Benjamin Rochard/Jean-Philippe Monclin</li>



<li><strong>Working Class Hero </strong>(e. Village Mystic) – Mathieu Mottier/Jörgen Westholm</li>



<li><strong>Justin Bold </strong>(e. Bold Eagle) – Pierre-Yves Verva/Jean-Rémi Delliaux</li>



<li><strong>Hip Hop Haufor</strong> (e. Up And Quick) – Damien Bonne/Christian Bigeon</li>
</ol>



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



<p class="has-drop-cap">2 För Sabine Kagebrant handlar det inte bara om Kilmister i Prix de France idag, utan en betydligt mer intressant uppgift har nyförvärvet <strong>Lovissime</strong> (e. Love You), 1.12,1m*/€219.550, i semi-classique-löpningen Prix Louis le Bourg (€120.000) för fyraåringar under sadel.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/pardieu4-617x342.jpg" alt="" class="wp-image-681569"/><figcaption class="wp-element-caption">Toppstammande Lovissime vid senaste segern. Foto: Gerard Forni</figcaption></figure>



<p>Stall Courant ropade in Lovissime på <a href="https://sulkysport.se/courant-kopte-dyrast/" data-type="link" data-id="https://sulkysport.se/courant-kopte-dyrast/" target="_blank" rel="noreferrer noopener">Prix d’Amérique-auktionen</a> för 460.000 euro och idag sker debuten för nya tränaren och stoet är favorit till segern och 54.000 euro i loppet som rids över 2.175 meter. Precis som vid förra segern – Prix de Pardieu (€120.000) – är det Guillaume Martin som sitter i sadeln.</p>



<p>Senare under dagen startar två svenskfödda travare på <strong>Vincennes</strong> (första start kl. 13.23) i Prix de Rouen (€90.000) över 2.850 meter. Daniel Wäjersten sitter upp bakom <strong>H.C.’s Crazy Horse </strong>(e. S.J.’s Caviar), medan Johan Untersteiner lånar ut <strong>Global Dubhe</strong> (e. Brillantissime) till Franck Ouvrie. Förstapriset i Grupp III-loppet för sexåringar uppgår till 40.500 euro.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-02-09/" target="_blank" rel="noreferrer noopener">Här hittar ni startlistorna till Vincennes tävlingar.</a></p>



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



<p class="has-drop-cap">3 Annelie Lagergren har genom åren plockat fram en hel del segermaskiner tillsammans med pappa Per-Gunnar Persson. <strong>Per Viking</strong> (e. Järvsöviking) inledde karriären sent som femåring med åtta raka segrar och har vunnit 16 av 37 starter hittills. En annan är <strong>Perso</strong> (e. Björs Frej) som å sin sida började med fyra raka segrar efter debut i oktober som femåring.</p>



<p>Dessa har hunnit bli tio år, men är fortsatt i elden. Det är också nykomlingen, sexårige <strong>Perto</strong> (e. Lome Brage), som debuterade – just det! – i oktober förra året som femåring. Visserligen blev det en andraplats i debuten, men sedan har den nu sexårige travaren plockat tre raka segrar.</p>



<p>När hemmabanan <strong>Bollnäs</strong> (första start 13.45) är enda svenska bana med tävlingar idag, så finns Perto med på Grand Slam 75-spelet med Jorma Kontio i vagnen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/02/09gs75.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 Franska travförbundet SETF tar ägaransvar och inrättar en styrkommitté för att försöka få ordning på spelbolaget PMU:s verksamhet. Bakgrunden till travförbundets ställningstagande är den ekonomiska situationen och farhågorna i samband med PMU:s fallande omsättning.</p>



<p>Moderbolagets styrelseledamöter ställer som krav att inrätta en ”krisgrupp” för att försöka stoppa den nedåtgående trend som PMU upplevt på alla fronter under 2024, vilket inkluderar spel på hästar, sport och poker.</p>



<p>En revision ska också genomföras hos PMU och detta efter en överenskommelse mellan France Galop och SETF.</p>



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



<p class="has-drop-cap">5 Glas &#038; Bågar har inte bara segermaskinen <strong>Global Agreement </strong>hos Alessandro Gocciadoro i träning. En annan vinstvan herre är valacken <strong>King Knas</strong> (e. Wishing Stone-Itchy Feet Pellini) och i fredags årsdebuterade han med seger i Premio Candelaria (€12.100) i Neapel med tränaren själv i sulkyn.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/skarmavbild20250208kl.09.38.25-617x286.jpg" alt="" class="wp-image-685713"/><figcaption class="wp-element-caption">King Knas vinner för Alessandro Gocciadoro.</figcaption></figure>



<p>I ett voltstartlopp hittade Alessandro Gocciadoro tredje utvändigt. Attacken sattes in i tredjespår vid utgången av sista sväng och enkelt avgjorde King Knas i spurten på 1.12,1/2.080 meter.</p>



<p>Ifjol blev det fem vinster och fyra andraplatser på 14 starter i Italien och 299.936 kronor insprunget. King Knas är undan <strong>Itchy Feet Pellini</strong> (e. Mack Lobell), 1.14,0am/330.500 kr, som också lämnat svenskfödda duon <strong>Captian Knas</strong> (426.700 kr) och <strong>Pokerface Pellini</strong> (411.566 kr).</p>



<p>Seger blev det också för en annan svenskfödd travare i Neapel. <strong>Ngannou</strong> (e. Mister J.P.-Baby Jane) räknade in sin nionde triumf på 18 starter när fyraåringen vann sitt tredje lopp för säsongen i Premio Los Cristianos (€10.010) för FrancescoTufano på 1.13,2a/2.100 meter.</p>



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



<p class="has-drop-cap">6 En efterlängtad födsel skedde på Haras de la Vallée d’Auge i Normandie torsdags kväll. Dubble Prix d’Amérique-vinnaren Idao de Tillards mor <strong>America de Tillard</strong> (e. First de Retz-Classe de Tillard), 1.16,0am/€29.300, nedkom med en hingst efter Just A Gigolo.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/skarmavbild20250208kl.08.32.35-617x427.jpg" alt="" class="wp-image-685714"/><figcaption class="wp-element-caption">America Tillards nyfödde son efter Just A Gigolo. Foto: Françoise Chaunion</figcaption></figure>



<p>För America de Tillard är det första avkomman på två år. Förutom <strong>Idao de Tillard</strong> (e. Severino), 1,09,4am*/€2.898.660, har hon lämnat <strong>Good de Tillard </strong>(e. Severino), 1.14,4l/€62.430, treårige <strong>Miracle de Tillard</strong> (e. Offshore Dream) och ett år yngre <strong>Newyork de Tillard</strong> (e. In the Money).</p>



<p>Nästa hingst är inte bestämd ännu, men uppfödaren Françoise Chaunion hintar om att nästa hingst kan bli Elitloppsvinnaren <strong>Hohneck</strong>.</p>



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



<p class="has-drop-cap">7 På San Siro avgörs Grupp III-löpningen Gran Premio Mario Locatelli (€25.300) och vars första upplaga hölls 1995. Distansen är 2.120 meter (voltstart) och har lockat 14 hästar sedan svenskbekantingen <strong>Heart of Steel</strong> strukits. </p>



<p>Däremot startar dubbla svenska rekordhållaren <strong>Marion Fouty Bon</strong> (e. Mister J.P.) som ägs av franska travförbundets ordförande Jean-Pierre Barjon och som tränas av Holger Ehlert.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2021/08/marionfoutybonjkm210811adamstromstalltz.jpg" alt="" class="wp-image-198717"/><figcaption class="wp-element-caption">Marion Founty Bon och Jorma Kontio vid en tidigare vinst. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p><strong>Gran Premio Mario Locatelli </strong>(€25.300)<br>Äldre travare.<br><em>2.120 meter, voltstart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Cienfuegos</strong> Laumar (e. Ganymede) – Pietro Gubellini</li>



<li><strong>Caos </strong>(e. Vivid Wise As) – Francesco Facci</li>



<li><strong>Castaldo Cas</strong> (e. Equinox Bi) – Gaetano di Nardo</li>



<li><strong>City Lux</strong> (e. Wishing Stone) – Riccardo Pezzatini</li>



<li><strong>Cocco Bfc</strong> (e. Varenne) – Santo Mollo</li>



<li><strong>Eclissi di Re Dr </strong>(e. Wishing Stone) – Francesco di Stefano</li>



<li><em>Heart of Steel – struken</em></li>



<li><strong>Diamond Francis</strong> (e. Exploit Caf) – Andrea Farolfi</li>



<li><strong>Etereo Jet</strong> (e. Igor Font) – Lorenzo Besana</li>



<li><strong>Etranger Joyeuse</strong> (e. Traders) – Andrea Guzzinati</li>



<li><strong>Due Italia</strong> (e. Adrian Chip) – Marco Stefani<br><em>2.140 meter:</em></li>



<li><strong>Enock</strong> (e. Vivid Wise As) – Manuele Matteini</li>



<li><strong>Cuba del Duomo</strong> (e. Varenne) – Rene Legati</li>



<li><strong>Marion Fouty Bon</strong> (e. Mister J.P.) – Davide Di Stefano</li>



<li><strong>Dylan Dog Font</strong> (e. Ringostarr Treb) – Vincenzo Luongo</li>
</ol>
