
<p class="has-drop-cap">1 Prix de Cornulier (€700.000) – världens största sadellopp med 315.000 euro till vinnaren – är den stora godbiten på Vincennes idag. De flesta blickar riktas mot <strong>Flamme du Goutier</strong> och Ready Cash-dottern jagar tredje raka segern för Mathieu Mottier.</p>



<p>Skulle hon lyckas skriver hos in sig i historieböckerna som första sto som klarat av tre raka segrar – något som hingstarna <a href="https://sulkysport.se/sla-den-femlingen-om-ni-kan/" data-type="link" data-id="https://sulkysport.se/sla-den-femlingen-om-ni-kan/" target="_blank" rel="noreferrer noopener">Souarus</a> 1946-1948 och <strong>Jag de Bellouet </strong>2004-2006 klarat av tidigare.</p>



<p>Flamme du Goutiers uppfödare ska inte heller glömmas bort. Bakom S.C.E.A. des Bissons döljer sig Jean Cottin och han har 19 Grupp I-vinnare – tolv inom travsporten och de andra sju med fullblod – på sitt samvete. Inom travsporten har han följande Grupp I-vinster:</p>



<ul class="wp-block-list">
<li><strong>Prix de l’Etoile</strong> – 2005 – Onyx du Goutier</li>



<li><strong>Prix d’Essai</strong> – 2009 – Scipion du Goutier</li>



<li><strong>Prix des Elites</strong> – 2009 – Scipion du Goutier</li>



<li><strong>Prix de Vincennes</strong> – 2009 – Scipion du Goutier</li>



<li><strong>Prix des Centaures</strong> – 2010 – Scipion du Goutier</li>



<li><strong>Prix des Centaures</strong> – 2011 – Scipion du Goutier</li>



<li><strong>Prix du Présidente de la République</strong> – 2010 – Scipion du Goutier</li>



<li><strong>Prix de Normandie</strong> – 2020 – Flamme du Goutier</li>



<li><strong>Prix de l’Ile-de-France</strong> – 2021 – Flamme du Goutier</li>



<li><strong>Prix des Centaures</strong> – 2021 – Flamme du Goutier</li>



<li><strong>Prix de Cornulier</strong> – 2022 – Flamme du Goutier</li>



<li><strong>Prix de Cornulier</strong> – 2023 – Flamme du Goutier</li>
</ul>



<p>Tränaren Thierry Duvaldestin har en spännade tid framöver – Flamme du Goutier är favorit till Prix de Cornulier idag och nästa söndag <strong>Idao de Tillard </strong>till vinsten i Prix d&#8217;Amérique. </p>



<h2 class="wp-block-heading">Startlista:</h2>



<p><strong>Prix de Cornulier</strong> (€700.000)<br>4-11 år, hingstar &#038; ston.<br><strong>Priser:</strong> 315.000-175.000-98.000-56.000-35.000-14.000-7.000 euro.<br><em>2.700 meter, monté.</em></p>



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



<ol class="wp-block-list">
<li><strong>Halfa</strong> (e. Offshore Dream) – Alan Gendrot/Stéphane Levoy</li>



<li><strong>Hannah</strong> (e. Vulcain de Vandel) – Florian Desmigneux/Jean-Francois Senet</li>



<li><strong>Ibiki de Houelle</strong> (e. Love You) – Eric Raffin/Franck Leblanc</li>



<li><strong>Gold Voice </strong>(e. Jag de Bellouet) – Benjamin Rochard/Fabrice Souloy</li>



<li><strong>Georgica Gede</strong> (e. Atlas de Joudes) – Guillaume Martin/Alexandre Pillon</li>



<li><strong>Fine Perle of Love</strong> (e. Theo Josselyn) – Pierre-Yves Verva/Emmanuel Varin</li>



<li><strong>Geisha Speed </strong>(e. Uriel Speed) – Anthony Barrier/Jean-Philippe Monclin</li>



<li><strong>Fougue Dollar</strong> (e. Up and Quick) – Dylan Dulong/Sylvain Roger</li>



<li><strong>Editon Gema </strong>(e. Prince Gede) – Gaëlle Godard/Marc Sassier</li>



<li><strong>Dynasty Peji </strong>(e. Prodigious) – Damien Bonne/Damien Bonne</li>



<li><strong>Vaprio</strong> (e. Adrian Chip) – Nathalie Henry/Alessandro Gocciadoro</li>



<li><strong>Esperanza Idole</strong> (e. Quido du Goutier) – Jean-Yann Ricart/Noël Langlois</li>



<li><strong>Ina du Rib </strong>(e. Uhlan du Val) – Jean-Luc Claude Dersoir/Joel Hallais</li>



<li><strong>Hirondelle du Rib</strong> (e. Rolling d’Heripre) – Noé Perron/Joel Hallais</li>



<li><strong>Ideale du Chene </strong>(e. Bird Parker) – Paul-Philippe Ploquin/Julien le Mer</li>



<li><strong>Hanna des Molles</strong> (e. Village Mystic) – Francois Lagadeuc/Laurent-Claude Abrivard</li>



<li><strong>Granvillaise Bleue</strong> (e. Jag de Bellouet) – Camille Levesque/Pierre Levesque</li>



<li><strong>Flamme du Goutier </strong>(e. Ready Cash) – Mathieu Mottier/Thierry Duvaldestin</li>
</ol>



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



<p class="has-drop-cap">2 På <strong>Vincennes</strong> idag (kl. 13.23) dyker också några svensktränade travare upp och det är Tomas Malmqvist som står för hela showen. Franck Nivard kör <strong>Koelho de Nappes</strong> (e. Charly du Noyer) i Prix de la Beauce (€52.000) för fyraåriga hingstar och valacker över 2.100 meter autostart.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/01/00243313020scoopdyga-617x411.jpg" alt="" class="wp-image-538771"/><figcaption class="wp-element-caption">Italienskan Chance Ek höll säkert undan för Björn Goop och Coquaholy på Vincennes. Idag finns chans till revansch för andraplatsen. Foto: Scoopdyga</figcaption></figure>



<p>I Prix Michel-Marcel Gougeon (€90.000) – tidigare namngivit Prix de Dinan – för sexåringar över 2.700 meter sköter Franck Nivard tömmarna bakom <strong>Invictus Madiba </strong>(e. Booster Winner) och Eric Raffin tar hand om <strong>Isla Jet </strong>(e. Bold Eagle), medan Björn Goop är uppsatt i sulkyn bakom svenskfödde <strong>Coquaholy </strong>(e. Orlando Vici) i Prix de Mirande (€90.000) för femåringar över 2.700 meter.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-01-21/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-01-21/" target="_blank" rel="noreferrer noopener">Startlistorna hittar ni här.</a></p>



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



<p><strong>Hästnamn (far) – Tränare – Placering – Prispengar</strong></p>



<ul class="wp-block-list">
<li><strong>Bordeaux S.</strong> (e. Orlando Vici) – Jean-Michel Bazire – trea – 12.600 euro</li>



<li><strong>Kentucky River </strong>(e. Father Patrick) – Daniel Redén – fyra – 7.200 euro</li>



<li><strong>Kobalt du Vallon</strong> (e. Quaker Jet) – Tomas Malmqvist – sex – 2.400 euro</li>



<li><strong>Power</strong> (e. Googoo Gaagaa) – Robert Bergh – sjua – 900 euro</li>



<li><strong>Mahala</strong> (e. Propulsion) – Daniel Redén – opl. – 0 euro</li>



<li><strong>Pinto Bob </strong>(e. Maharajah) – Robert Bergh – opl. – 0 euro</li>
</ul>



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



<p class="has-drop-cap">3 Finländaren Matti Nisonen har gjort sitt första år som proffstränare på svensk mark, då han fick Solvallalicens inför 2023. Fast det handlar om en van Sverige-gäst som arbetade en handfull år hos Kari Lähdekorpi, Timo Nurmos och Stefan Melander på 2000-talet. Han gick svenska proffstränarkursen, men satsade på en proffskarriär i Finland, främst som privattränare för familjen Vidgrens hästar.</p>



<p>När <strong>Romme </strong>(första start 13.45) tävlar i eftermiddag plockar Nisonen ut tre av stallets tolv hästar och alla ägs av Einari Vidgren Oy. Det handlar om trion <strong>Djokovic</strong> (e. Bold Eagle), <strong>Gianluca D.K.</strong> (e. Djali Boko) och <strong>Matteo de Veluwe</strong> (e. Brad de Veluwe), där den sistnämnde spräckte stallets segernolla 2024 när han vann i Eskilstuna för drygt två veckor sedan.</p>



<p>Matteo de Veluwe har visat gott kunnande sedan han kom från Finland i höstas och vunnit två av fyra starter sedan dess.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/01/21gs75.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/01/21gs75.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 Frode Hamre inledde en ny säsong med sitt storloppsess <strong>Stoletheshow</strong> (e. Dream Vacation) på Bjerke igår och det blev ett fint besked inför den elvafaldige miljonärens åttonde år på banan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/stoletheshowdexterdunn-617x333.jpg" alt="" class="wp-image-452132"/><figcaption class="wp-element-caption">Stoletheshow tillsammans med Dexter Dunn på Solvalla förra året. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>I högsta klassen stack Stoletheshow till ledningen efter 300 meter och efter 1.10,7 första 500 meterna blev det närmast marsch på stället med megafavoriten i tät.</p>



<p>400 meter från mål lade Hamre in en extra växel och Stoletheshow fick på några steg ett rejält försprång och defilerade upploppet ned till plättlätt seger på 1.13,5a/2.100 meter.</p>



<p>Charleston Volo (e. Classic Photo) var tvåa från andra utvändigt och dödenstravande Miss Pepper (e. Quite Easy) tog tredjeplatsen. Därmed har Stoletheshow, som ägs i Sverige av Global Glide AB (Süleyman Yüksel), vunnit 28 av 87 segrar i karriären.</p>



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



<p class="has-drop-cap">5 <strong>Etonnant</strong> är borttagen ur Prix d’Amérique och det kom inte som någon större överraskning och hästens tränare Richard Westerink har varit tydligt med att han inte startar sin stjärna ”till varje pris”.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/richardwesterink2-617x333.jpg" alt="" class="wp-image-308556"/><figcaption class="wp-element-caption">Richard Westerink berättade igår att Etonnant står över Prix d&#8217;Amérique. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>– Han är inte tillräckligt bra för att vara med, berättade Richard Westerink för ”24 au Trot.”</p>



<p>Det betyder att <strong>Aetos Kronos </strong>är klar för Prix d’Amérique och inför morgondagens anmälningar knackar också Robert Berghs <strong>Power </strong>på dörren. I dagsläget blir det minst tre svensktränade hästar i Prix d’Amérique; Aetos Kronos, <strong>Hail Mary</strong> och <strong>Joviality</strong>.</p>



<p><strong>Nedanstående tio hästar har kvalat in till Prix d’Amérique:</strong></p>



<ul class="wp-block-list">
<li>Ampia Mede Sm</li>



<li>Emeraude de Bais</li>



<li>Go On Boy</li>



<li>Gu d’Heripre</li>



<li>Hokkaido Jiel</li>



<li>Hooker Berry</li>



<li>Hussard du Landret</li>



<li>Idao de Tillard</li>



<li>Inmarosa</li>



<li>Izoard Vedaquais</li>
</ul>



<p><strong>Och i dagsläget kommer följande åtta med på pengar:</strong></p>



<ul class="wp-block-list">
<li>Vivid Wise As – €3.627.158</li>



<li>Joviality* – €2.769.874 (+ 20%)</li>



<li>Hohneck – €2.277.005</li>



<li>Delia du Pommereux – €1.893.755</li>



<li>Cokstile – €1.828.968</li>



<li>Flamme du Goutier – €1.601.955</li>



<li>Hail Mary – €1.475.239</li>



<li>Aetos Kronos – €1.200.19<strong>4</strong></li>
</ul>



<p><strong>Reserver:</strong></p>



<ul class="wp-block-list">
<li>Diable de Vauvert – €1.162.190</li>



<li>Power – €1.147.291</li>
</ul>



<p><strong>Fotnot:</strong> *femåringar får plussa på 20 procent på prissumman och sexåringar 10 procent.</p>



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



<p class="has-drop-cap">6 Dyrast på Travera-auktion igår blev tvåårige <strong>Gambler Kronos</strong> (e. Face Time Bourbon-Only Kronos) och det var Stall Denco HB som köpte och det var sannerligen ingen rolig prognos för den som orkade läsa genom <a href="https://sulkysport.se/wp-content/uploads/2024/01/vetgambler.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/01/vetgambler.pdf" target="_blank" rel="noreferrer noopener">veterinärintyget</a>. Hela 160.000 kronor betalades i alla fall för den tvåårige hingsten och av fem budgivare (!) hade storstallet Denco högsta budet…</p>



<p>Veterinären Bengt Johansson skrev bland annat;<em> ”prognos som travhäst tveksam alternativ dålig.”</em></p>



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



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



<p class="has-drop-cap">7 I fredags hade ASVT internetauktion och två hästar såldes. Dyrast blev fölstoet <strong>Drottning Pace</strong> (e. Gift Kronos-Atttraction Call), 1.13,0ak/397.100 kr, för 23.000 kronor. Köpare var Kim Kaerslund i Danmark. Stoet var dräktig med <strong>Trixton</strong> och i priset ingick fölavgiften på 50.000 kronor.</p>



<p>Två avkommor har Drottning Pace; tvåårige <strong>Mercury Pace </strong>(e. Traders) och en ettårig hingst efter Day Or Night In. Själv ingår modern i samma syskonskara som <strong>Adams Pace</strong> (564.900 kr) och <strong>Bruiser Pace </strong>(399.250 kr).</p>
