
<p class="has-drop-cap">1 Nio svensktränade travare har vunnit <a href="https://sulkysport.se/vinst-eller-nitlott/" data-type="link" data-id="https://sulkysport.se/vinst-eller-nitlott/" target="_blank" rel="noreferrer noopener">Prix de France</a> (€400.000) och idag deltar sju travare som tränas av svenskstationerade tränare, men den franska dagliga travtidningen Paris-Turf har ingen större tilltro till travarna från Norden.</p>



<h2 class="wp-block-heading">Svensktränade vinnare i Prix de France:</h2>



<p><strong>År – Häst – Tränare – Ägare</strong></p>



<ul class="wp-block-list">
<li>1992 – <strong>Atas Fighter L.</strong> – Torbjörn Jansson – Stall Travhästen</li>



<li>1995 – <strong>Queen L.</strong> – Stig H Johansson – AB Tore Larsson &#038; Co, Stockholm</li>



<li>1997 – <strong>Lovely Godiva</strong> – Per-Olof Pettersson – Team Cocoloco HB</li>



<li>1999 – <strong>Moni Maker </strong>– Jimmy Takter – Moni Maker Stable, USA</li>



<li>2003 – <strong>Hilda Zonett</strong> – Robert Bergh – Stall Zonett</li>



<li>2004 – <strong>Naglo</strong> – Stefan Hultman – Corebus AB, Danderyd</li>



<li>2005 – <strong>Naglo</strong> – Stefan Hultman – Corebus AB, Danderyd</li>



<li>2014 – <strong>Noras Bean</strong> – Ulf Stenströmer – Stall Åsunden HB, Ulricehamn</li>



<li>2019 – <strong>Readly Express</strong> – Timo Nurmos – Bro Byggnads AB, Stockholm</li>
</ul>



<p>Allra högst upp rankas Sabine Kagebrants Prix d’Amérique-trea <a href="https://sulkysport.se/kan-inte-ha-tur-jamt/" data-type="link" data-id="https://sulkysport.se/kan-inte-ha-tur-jamt/" target="_blank" rel="noreferrer noopener">Joviality</a> (e. Chapter Seven), följd av Daniel Redéns duo <strong>Hail Mary</strong> (e. Googoo Gaagaa) och <strong>Missle Hill</strong> (e. Muscle Hill)</p>



<p><strong>Så här rankar Paris-Turf Prix de France:</strong></p>



<ol class="wp-block-list">
<li>Idao de Tillard</li>



<li>Go On Boy</li>



<li>Vivid Wise As</li>



<li>Ampia Mede Sm</li>



<li><strong>Joviality </strong>(Sabine Kagebrant)</li>



<li>Hokkaido Jiel</li>



<li>Hooker Berry</li>



<li><strong>Hail Mary</strong> (Daniel Redén)</li>



<li>Emeraude de Bais</li>



<li>Italiano Vero</li>



<li><strong>Missle Hill </strong>(Daniel Redén)</li>



<li>Inmarosa</li>



<li>Horsy Dream</li>



<li><strong>Power </strong>(Robert Bergh)</li>



<li><strong>Dear Friend</strong> (Daniel Wäjersten)</li>



<li><strong>Aetos Kronos</strong> (Jerry Riordan)</li>



<li>Delia du Pommereux</li>



<li><strong>Moni Viking </strong>(Björn Goop)</li>
</ol>



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



<p class="has-drop-cap">2 <strong>Vincennes</strong> (första start kl. 13.58) lockar inte bara med Prix de France utan det är flera topplopp under tävlingsdagen. <strong>Jushua Tree</strong> (e. Bold Eagle) gör sin första start efter Grupp I-segern i Prix Bold Eagle (€300.000) under Prix d’Amérique-helgen och möter återigen bara jämngamla konkurrenter då det handlar om Prix Ovide Moulnet (€120.000) för inhemska hästar. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/julesthibault3-617x397.jpg" alt="" class="wp-image-456093"/><figcaption class="wp-element-caption">Jean-Michel Bazire och Jushua Tree. Foto: Gerard Forni</figcaption></figure>



<p>Blott åtta konkurrenter tar striden i detta lopp över 2.700 meter voltstart där vinnaren belönas med 54.000 euro. Det betyder att återigen undviker de franska topphästarna Jushua Tree och Idao de Tillard varandra&#8230;</p>



<p>Prix de Rouen (€90.000) för sexåringar bär Grupp III-status och innehåller fyra svensktränade deltagare. Tomas Malmqvist startar såväl <strong>Donizetti </strong>(e. Maharajah) som körs av Björn Goop som <strong>Invictus Madiba</strong> (e. Booster Winner), vilken kamperar ihop med Franck Nivard, Johan Untersteiner kör egentränade <strong>Karat River</strong> (e. Muscle Hill) och så kuskar Yoann Lebourgeois bakom Daniel Redéns <strong>Felicia Zet</strong> (e. Ready Cash).</p>



<p>En svensktränad springare startar även i Prix de Bouguenais (€40.000) och då handlar det om Marie Norbergs <strong>Justess Viking</strong> (e. Ubriaco).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-02-11/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-02-11/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar.</a></p>



<h2 class="wp-block-heading">Så gick det för svenskhoppen igår på Vincennes:</h2>



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



<ul class="wp-block-list">
<li><strong>Imhatra Am</strong> (e. Muscle Hill) – Jörgen Westholm – tvåa – 22.500 euro</li>



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



<li><strong>Mahala</strong> (e. Propulsion) – Daneil Redén – fyra – 4.160 euro</li>



<li><strong>Bordeaux S.</strong> (e. Orlando Vici) – Jean-Michel Bazire – femma – 3.750 euro</li>



<li><strong>Junkie</strong> (e. Varenne) – Pierre Levesque – sjua – 520 euro</li>



<li><strong>Carbonfiber</strong> (e. Uncle Lasse) – Vitale Ciotola – oplacerad – 0 euro</li>



<li><strong>Jockstrap </strong>(e. Prince Gede) – Jarmo Niskanen – oplacerad – 0 euro</li>



<li><strong>Kapitano de Source</strong> (e. Ready Cash) – Tomas Malmqvist – diskad – 0 euro</li>



<li><strong>Sayonara</strong> (e. Donato Hanover) – Fredrik Wallin – oplacerad – 0 euro</li>
</ul>



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



<p class="has-drop-cap">3Italienaren Gennaro Casillos hästar har varit en återkommande syn på svenska banor de senaste åren – och med framgång dessutom. <strong>Charliebrown Effe</strong> (e. Conway Hall) hade ett dunderår som fyraåring 2022, då han efter att ha inlett i Italien och på Vincennes kom till Sverige på vårkanten. Tio segrar på 14 starter bjöd den säsongen på och vägen var utstakad mot högre höjder.</p>



<p>Riktigt så enkelt blev det inte. Ifjol fick han nöja sig med en seger på 14 försök – i ett silverförsök på Axevalla under Stochampionatshelgen – men hästen har samtidigt tagit klivet in i gulddivisionen. Med årsdebuten avklarad kliver han ut i ett flerklasslopp på <strong>Axevalla </strong>(första start 13.45) idag.<br>Det skulle ha varit hästar på tre volter, men <strong>Keep Flying Rapida</strong> (e. Yarrah Boko) inleder ensam på startfållan och 40 meter bakom jagar sex miljonärer med <strong>Charliebrown Effe</strong> i spetsen. </p>



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



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



<p class="has-drop-cap">4 En travare såldes för sexsiffrigt belopp på Travera igår och det var Elitloppsvinnaren Steinlagers tränare Per Oleg Midtfjeld som hade högsta budet. För fyraårige valacken <strong>Charlie Laross </strong>(e. Readly Express-Global Upside Down), 1.17,0m/81.000 kr, betalade han 170.000 kronor.</p>



<p>Åtta starter (2-1-1) har hästen gjort i Kevin Oscarssons regi och båda vinsterna har tagits på Kalmartravet.</p>



<p><a href="https://www.travera.nu/auktionsresultat/" data-type="link" data-id="https://www.travera.nu/auktionsresultat/" target="_blank" rel="noreferrer noopener">Samtliga resultat från Travera-auktionen hittar ni här.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/02/hierroboko-617x192.jpg" alt="" class="wp-image-550501"/><figcaption class="wp-element-caption">Som tvåa i mål gjorde Hannu Korpi segergest bakom Upper Face när han såg stallkamraten Hierro Boko vinna högsta klassen i Seinäjoki igår.</figcaption></figure>



<p class="has-drop-cap">5<strong>Hierro Boko</strong> (e. From Above) är tidernas snabbaste svenskfödde vinnare i Europa efter att han tillsammans med Santtu Raitala vunnit S:t Michel Race i Mikkeli förra sommaren på 1.08,3a/1.609 meter. Igår gjorde hästen tredje starten för året och det handlade om helt andra förutsättningar på isbanan i Seinäjoki, där Jarmo Saarela körde till ledningen under först rundan och sedan lämnade konkurrenterna över upploppet till seger på 1.16,2a/2.100 meter.</p>



<p>Tränar gör Hannu Korpi – kanske mest känd som brandmannen bakom STL-profilen <strong>Grainfield Aiden</strong> – och han fanns själv med i loppet bakom en annan svenskfödd travare, <strong>Upper Face</strong> (e. Trixton), som spurtade till andraplatsen och den dubbeln firade måltvåan med rejäl segergest.<br>10.500 euro var belöningen för Korpis båda hästar.</p>



<p>Frode Hamre fyllde 60 år igår och firade födelsedagen med kvällstävlingar på Sörlandet. Det blev ett trivsamt firande när Hamre tog en trippel. Bland vinnarhästarna fanns svenskägde <strong>Stoletheshow</strong> (e. Dream Vacation), som joggade hem 70.000 kronor från ledningen i högsta klassen på 1.14,5a/2.140 meter.<br>– Han har vunnit några enkla lopp och det gör gott för hans psyke. Jag har lust att matcha honom lite försiktigt i år, sade Hamre enligt Trav- og Galopp-Nytt.</p>



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



<p class="has-drop-cap">6 Det bjuds inte bara på storlopp i Paris idag. I Italien avgörs Grupp III-loppet Gran Premio Mario Locatelli (€35.200) på La Maura-banan i Milano. Där startar Alessandro Gocciadoro svenskfödde <strong>Bythebook </strong>(e. Googoo Gaagaa) och han ställs mot <strong>Chance Ek</strong> (e. Nad al Sheba), vilken inledde året med seger på 1.11,1a/2.100 meter i Prix d’Agouleme (€71.000) på Vincennes.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/02/skarmavbild20240205kl.15.41.00.png" alt="" class="wp-image-549458"/></figure>



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



<p class="has-drop-cap"><em>7</em> Efter en sjätteplats i finalen i Great Southern Star hade nyzeeländaren <strong>Mufasa Metro</strong> (e. Father Patrick-Paris Metro) en betydligt enklare uppgift på papperet när sjuåringen plockade ner ledande Im Ready Jet (e. Quaker Jet) sista biten i Cranbourne Trotters Cup ($50.000) på Cranbourne igår.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/02/mufasametro20221118-617x385.jpg" alt="" class="wp-image-550486"/><figcaption class="wp-element-caption">Mufasa Metro vid en tidigare seger. </figcaption></figure>



<p>Favoriten Im Ready Jet ledde länge, men fick ge sig med knapp marginal mot Mufaso Metro och John Justice på 1.15,6a/2.555 meter. Förstapriset uppgick till 28.500 australiska dollar för fjolårets Inter Dominion Trotting Championship-tvåa, vilken tog sin första seger sedan den 18 mars förra året.</p>



<p>Mufasa Metro är undan <strong>Paris Metro</strong>, 1.15,7/$120.606, vilken är en dotter till passgångaren Safely Kept. Förutom Mufasa Metro ($344.355) har hon lämnat <strong>Massive Metr</strong>o ($257.085) och<strong> Commander Paris</strong> ($122.373).</p>
