
<p class="has-drop-cap">1 Alla blickar mot Paris idag och världens största löpning för sadelhästar. Hela 315.000 euro väntar vinnaren i Prix de Cornulier (€700.000) och där startar ett koppel av framstående montéhästar och den stora frågan är om nioåriga ”gröngölingen” <strong>Gazelle du Val</strong> (e. Viking du Val) är fortsatt obesegrad under sadel – sju raka triumfer – efter eftermiddagens lopp.</p>



<p>Gazelle du Val ställs mot betydligt mer rutinerade motståndare såsom dubbla Prix de Cornulier-tvåan <strong>Granvillaise Bleue</strong>, fjolårstrean <strong>Ideale du Chene</strong> och <strong>Joumba de Guez</strong> för att nämna några. I sammanhaget ska också sägas att de fyra senaste upplagorna av Prix de Cornulier har vunnits av ston.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/skarmavbild20250118kl.09.14.16-617x348.jpg" alt="" class="wp-image-679377"/><figcaption class="wp-element-caption">Thomas, Pierre och Camille Levesque. Foto: stalltz.se</figcaption></figure>



<p>Stoet <strong>Granvillaise Bleue </strong>tränas av Pierre Levesque och han har aldrig vunnit loppet som tränare, men däremot som ryttare ovanpå Henri-Louis Levesque <strong>Mirande du Cadran</strong> 1985. </p>



<p>I normala fall brukar Pierres dotter Camille rida stoet, men hon är gravid och därför sitter Alexandre Abrivard upp i sadeln. Pierres son Thomas har också en häst till start – <strong>Gold Voice</strong> – och Thomas är också högaktuell veckan därpå i Prix d’Amérique med stoet <strong>Iroise de la Noe</strong> efter hennes imponerande seger i Prix de Belgique.</p>



<p><strong>Så här rankar dagstidningen Paris-Turf loppet: </strong>5-8-17-13-2-15-18-1-4-24-16-11-9-7-12-6-3-10.</p>



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



<p class="has-drop-cap">2 Prix de Cornulier reds första gången 1931 och fem hästar har lyckats vinna loppet tre gånger: <strong>Souares </strong>(1946, 1947, 1948), <strong>Gardon</strong> (1955, 1956,1958), <strong>Bellino II </strong>(1973, 1975, 1976), <strong>Kaiser Trot </strong>(1981, 1982, 1984) och <strong>Jag de Bellouet</strong> (2004, 2005, 2006).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/02/jagdebellouetmal2006smtz-617x512.jpg" alt="" class="wp-image-1455"/><figcaption class="wp-element-caption">Jag de Bellouet med Mathieu Abrivard vid en av hans segrar i Prix de Cornulier. Foto Stalltz.se</figcaption></figure>



<p>Skulle <strong>Granvillaise Bleue </strong>vinna idag blir Jag de Bellouet den första avelshingsten som både vunnit och lämnat en vinnare av Prix de Cornulier sedan <strong>First de Retz</strong> son <strong>One du Rib </strong>vann 2010.</p>



<p>Löpningsrekordet i Prix de Cornulier har <strong>Bilibili </strong>(e. Niky) från 2019 med tiden 1.11,2/2.700 meter. Den dominerande tränaren i löpningens historia är Joël Hallais med åtta vinnare; <strong>Kaiser Trot</strong> (1981, 1982, 1984), <strong>Oligo</strong> (1986,1987), <strong>Tout Bon</strong> (1993), <strong>One du Rib </strong>(2007, 2010). I årets upplaga selas två hästar ut från Hallais stall – <strong>Ina du Rib </strong>och <strong>Hirondelle du Rib</strong> – varav den sistnämda slutade tvåa ifjol i Prix de Cornulier.</p>



<p>Segerrikaste ryttare är Jean Mary med åtta vinster, men Jean-Luc Claude Dersoir kan ta sig ett steg närmare om hans uppsittning Ina du Rib lyckas vinna. Jean-Luc har vunnit ovanpå <strong>Tout Bon </strong>(1993), dubbla upplagor med <strong>First de Retz </strong>(2000, 2001) och <strong>One du Rib </strong>2007. Vid seger idag skulle det vara 11.683 dagar mellan segrarna…</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/04/nordinulfstalltzsm-617x338.jpg" alt="" class="wp-image-21193"/><figcaption class="wp-element-caption">Ulf Nordin Foto: stalltz.se</figcaption></figure>



<p>Noteras i sammanhanget kan också att Ulf Nordin vunnit loppet två gånger som tränare med <strong>Voici du Niel </strong>1992 och <strong>Magnificent Rodney</strong> 2008.</p>



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



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



<p><strong>Namn (far) – Ryttare</strong></p>



<ol class="wp-block-list">
<li><strong>Jasmine de Vau</strong> (e. Seduisant Fouteau) – Guillaume Lenain</li>



<li><strong>Jezabelle Bie </strong>(e. Dijon) – Adrien Lamy</li>



<li><strong>Intouchable </strong>(e. Prodigious) – Francois Lagadeuc</li>



<li><strong>Jewelcandle Fac</strong> (e. Prodigious) – Damien Bonne</li>



<li><strong>Gazelle de Val</strong> (e. Viking de Val) – Mathieu Mottier</li>



<li><strong>Guide Moi Forgan</strong> (e. Neutron du Cebe) – Anthony Barrier</li>



<li><strong>Gold Voice </strong>(e. Jag de Bellouet) – Clément Frecelle</li>



<li><strong>Joumba de Guez</strong> (e. Carat Williams) – Eric Raffin</li>



<li><strong>J’Aime Le Foot </strong>(e. Boccador de Simm) – Alexis Collette</li>



<li><strong>Ines des Rioults</strong> (e. Carat Williams) – Florian Desmigneux</li>



<li><strong>Hip Hop Haufor</strong> (e. Up and Quick) – Pierre-Yves Verva</li>



<li><strong>Grace du Digeon</strong> (e. Seduisant Fouteau) – Jean-Yann Ricart</li>



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



<li><strong>Jean Balthazar</strong> (e. Alto de Viette) – Benjamin Rochard</li>



<li><strong>Edition Gema</strong> (e. Prince Gede) – Marc Sassier</li>



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



<li><strong>Ideal du Chene </strong>(e. Bird Parker) – Paul-Philippe Ploquin</li>



<li><strong>Granvillaise Bleue</strong> (e. Jag de Bellouet) – Alexandre Abrivard</li>
</ol>



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



<p class="has-drop-cap">3 Många penningstinna löpningar hålls på Vincennes största dag för sadelhästarna. En svenskfödd travare tar chansen och Jörgen Westholm plockar ut <strong>Beat Generation</strong> (e. Bird Parker) i Prix Celine Leclercq (€68.000) och den sjuårige hingsten rids av Eric Raffin. 30.600 euro väntar vinnaren i loppet som rids över 2.175 meter.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/06/beat3-scaled.jpg" alt="" class="wp-image-457878"/><figcaption class="wp-element-caption">Jörgen Westholms Beat Generation och Alexandre Abrivard. Foto: Gerard Forni</figcaption></figure>



<p>Förra året tävlade Beat Generation framgångsrikt under sadel på Vincenns med seger i Prix Indienne (€71.000) på 1.11,1/2.175 meter, men också med två andraplatser på franska landsorten.</p>



<p>Startar gör också Björn Goop med franskfödde <strong>Icarus Bourbon</strong> (e. Prodigious) i Prix de Chambord (€41.000) över 2.175 meter med 18.450 euro till vinnaren. </p>



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



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



<p class="has-drop-cap">4Förra året var det tävlingsfritt fyra dagar på svensk mark. 2025 skulle det ha blivit tävlingar varje dag, inklusive julafton med förmiddagstävlingar i Eskilstuna.<br>Men idag bryts den tänkta årslånga sviten med trav i Sverige. <strong>Boden</strong>, som skulle ha varit enda bana i farten idag, tvingas skjuta upp eftermiddagens tävlingar på grund av blidvädret som gör isbanan för riskabel att tävla på.</p>



<p>Kallare väder är på ingång och tävlingarna är uppskjutna till tisdag eftermiddag med första start 13.35.</p>



<p><a href="https://sulkysport.se/grand-slam-75-stalls-in/" target="_blank" rel="noreferrer noopener">Läs mer om tävlingsdagen här.</a></p>



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



<p class="has-drop-cap">5Global Glide-ägde <strong>Stoletheshow</strong> (e. Dream Vacation) skulle passera 15 miljoner norska kronor insprunget i karriären om han vann snabbloppet igår kväll på Bjerke, men trots spets och 1.16,8 första kilometern blev det ingen vinst för Frode Hamres travare. <strong>Cabron</strong> (e. Caballion) var starkast över upploppet.</p>



<p>Helena Edlund-tränade <strong>Beartime</strong> (e. Pastor Stephen) var snabbast från start och tog ledningen, bara för att släppa till Stoletheshow efter 150 meter. Sedan hände ingenting innan Åsbjörn Tengsareid lyfte ut Cabron i dödens efter en kilometer av medeldistansloppet. Tempot ökade direkt och det gick klart fortare ut på slutrundan. In på upploppet var Stolestheshow fortsatt först, men då gick Cabron i närkamp och avgjorde enkelt.<br>Segertiden skrevs till 1.15,2a/2.100 meter och förstapriset var 100.000 kronor. </p>



<p>Stoletheshow höll till andraplatsen på 1.15,4, medan Beartime blev fast med krafter kvar i rygg på megafavoriten som fyra på 1.15,6. Stoletheshow står därmed på 14.958.081 norska kronor i prissumma.</p>



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



<p class="has-drop-cap">6 Igår pensionerades Australiens stora stjärna <a href="https://sulkysport.se/sluttavlat-for-just-believe/" data-type="link" data-id="https://sulkysport.se/sluttavlat-for-just-believe/" target="_blank" rel="noreferrer noopener">Just Believe</a> och nu letar man förstås efter en arvtagare till honom. En häst som steppat upp är <strong>Arcee Phoenix</strong> (e. Trixton-Justa Phoenix) och igår vann han Grupp III-löpningen The Knight Pistol ($30.000) i Ballarat.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/skarmavbild20250118kl.15.19.49-617x300.jpg" alt="" class="wp-image-679391"/><figcaption class="wp-element-caption">Invändige Arcee Phoenix håller undan till vinst. </figcaption></figure>



<p>Chris Svanosio och Arcee Phoenix övertog täten efter 400 meter och sedan kunde duon bestämma farten därframme. Sista biten fick den sexårige valacken sträcka på sig för att hålla ifrån sig Aardiebythehill (e. Muscle Hill), som fick sen lucka från ledarryggen. </p>



<p>Arcee Phoenix kom hem på 1.13,5a/2.200 meter och det var andra raka segern. I förra starten tog Chris Svanosios häst hem Grupp I-klassade Maori Mile ($75.000) för andra året i rad.</p>



<p>Modern <strong>Justa Phoenix</strong> (e. Sundon), 1.14,9/$18.413, har förutom Justa Phoenix ($367.955) också lämnat <strong>Querenica </strong>(e. Andover Hall), 1.15,2/$49.084.</p>



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



<p class="has-drop-cap">7 En anonym köpare lade beslag på den dyraste hästen på Travera igår och betalade 390.000 kronor för Robert Bergh-tränade <strong>Ferrara </strong>(e. Readly Express-Big Blue Kitten), 1.11,3ak/396.600 kr, som vunnit fyra av 26 starter. Ferrara ingår i samma syskonskara som <strong>Yarrah Boko</strong> (e. Coktail Jet), 1.09,7ak<em>/</em>11.173.121 kr, <strong>Aristocat Boko </strong>(e. From Above), 1.12,0ak/1.968.509 kr, och <strong>Zola Boko</strong> (e. Goetmals Wood), 1.11,6am/1.950.214 kr.</p>



<p>Sexåriga stoet <strong>Victoria L.L.</strong> (e. From Above-Ester L.L.), 1.12,1ak*/498.798 kr, med tolv vinster på 33 starter, hamnade också hos en anonym köpare. Priset blev 210.000 kronor för hästen som tränas av danskan Lilllian Uglebjerg och som är på väg till Menhammar Stuteri som unghästränare.</p>



<p>Ytterligare en häst kom upp i sexsiffrigt och Eva Wahl betalade 180.000 kronor för <strong>Timotejs Messenger</strong> (e. Face Time Bourbon-Monas Ragazza), 1.15,5l*/92.500 kr, som vunnit ett lopp på 13 starter hos Jörgen Westholm.</p>



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