
<p class="has-drop-cap">1 Idag tävlas det om stora pengar på Vincennes, men också två platser i Prix d’Amérique (€1.000.000) nästa år. I båda Grupp I-löpningarna Criterium Continental (€240.000) och Prix Tenor de Baune (€240.000) erhåller vinnarna en biljett till Pd’A, men också 108.000 euro i förstapris.</p>



<p>I Prix Tenor de Baune startar Daniel Redéns <strong>Bengan </strong>(e. Django Riff) och Jörgen Westholm <strong>Working Class Hero </strong>(e. Village Mystic) och de är rankade trea respektive fyra i Paris-Turf efter <strong>Justin Bold</strong> (e. Bold Eagle) och <strong>Just Love You </strong>(e. Love You).</p>



<p>Tre svensktränade travare dyker också upp i Criterium Continental, men Paris-Turf tillmäter varken <strong>Crown</strong> (e. Chapter Seven), <strong>Global Etalon</strong> (e. Brillantissime) eller <strong>Kilmister </strong>(e. Chapter Seven) några större chanser. Högst rankad – som nia – är Daniel Redéns Crown. </p>



<p>Tippas etta gör <strong>Keep Going</strong> (e. Follow You) före Alessandro Gocciadoros duo <strong>Executiv Ek</strong> (e. Face Time Bourbon) och <strong>East Asia</strong> (e. Ready Cash), som körs av Björn Goop.</p>



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



<p><strong>Criterium Continental</strong> (€240.000)<br>Fyraåringar.<br><em>2.100 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Koctel du Dain</strong> (e. Boccador de Simm) – David Thomain/Philippe Allaire</li>



<li><strong>East Asia</strong> (e. Ready Cash) – Björn Goop/Alessandro Gocciadoro</li>



<li><strong>Keep Going</strong> (e. Follow You) – Mathieu Mottier</li>



<li><strong>Executiv Ek</strong> (e. Face Time Bourbon) – Eric Raffin/Alessandro Gocciadoro</li>



<li><strong>Crown </strong>(e. Chapter Seven) – Francois Lagadeuc/Daniel Redén</li>



<li><strong>Ninetta Boko</strong> (e. Father Patrick) – Jean-Michel Bazire/Erwin Bot</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Santo Mollo/Alessandro Gocciadoro</li>



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



<li><strong>Kana de Beylev</strong> (e. Express Jet) – Benjamin Rochard/William Bigeon</li>



<li><strong>Kyrielle </strong>(e. Enino du Pommereux) – William Bigeon</li>



<li><strong>Kristal Josselyn</strong> (e. Bold Eagle) – Anthony Barrier/Sébastien Guarato</li>



<li><strong>Katinka du Mouchel</strong> (e. Prodigious) – Clément Duvaldestin/Thierry Duvaldestin</li>



<li><strong>Kokote</strong> (e. Ready Cash) – Alexandre Abrivard/Mathieu Mottier</li>



<li><strong>Global Etalon </strong>(e. Brillantissime) – Magnus A Djuse/Fredrik Wallin</li>



<li><strong>Karlito</strong> (e. Ready Cash) – Youann Lebourgeois/Jean-Philippe Monclin</li>



<li><strong>Ksar </strong>(e. Follow You) – Matthieu Abrivard/Emmanuel Varin</li>



<li><strong>Khal’s Fella</strong> (e. Ready Cash) – Paul Philippe Ploquin/Fabrice Souloy</li>



<li><strong>Keenan de Joudes</strong> (e. Ready Cash) – Jean-Philippe Monclin</li>
</ol>



<p><strong>Prix Tenor de Baune</strong> (€240.000)<br>Femåringar.<br><em>2.700 meter.</em></p>



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



<ol class="wp-block-list">
<li><strong>Die Hard</strong> (e. Bird Parker) – Charley Heslouin/Pierre-Louis Desaunette</li>



<li><strong>Jour de Fete</strong> (e. Orlando Vici) – Tristan Ouvrie/Nicolas Bazire</li>



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



<li><strong>Jewelcandle Fac </strong>(e. Prodigious) – Damien Bonne/Sébastien Guarato</li>



<li><strong>Jango Vici</strong> (e. Dragon des Racques) – Benjamin Rochard/Antonio Ripoll Rigo</li>



<li><strong>Jakarta des Pres</strong> (e. Scipion du Goutier) – David Thomain/Emilien Raulline</li>



<li><strong>Bengan</strong> (e. Django Riff) – Francois Lagadeuc/Daniel Redén</li>



<li><strong>Jazzman Debailleul </strong>(e. Repeat Love) – Franck Ouvrie/Erno Szirmay</li>



<li><em>Joumba de Guez (e. Carat Williams) – struken</em></li>



<li><strong>Jack Tonic </strong>(e. Charly du Noyer) – Théo Duvaldestin/Thierry Duvaldestin</li>



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



<li><strong>Juninho Dry</strong> (e. Carat Williams) – Paul-Philippe Ploquin/Sébastien Guarato</li>



<li><strong>Just Love You</strong> (e. Love You) – Alexandre Abrivard/Laurent-Claude Abrivard</li>
</ol>



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



<p class="has-drop-cap">2Årets svenske banchampionkung heter Mats E Djuse. När <strong>Bollnäs </strong>(första start 13.45) idag kör årets sista tävlingsdag säkrar Mats sitt fjärde svenska banchampionat. Med 38 segrar i Bollnäs under säsongen är Hagmyrenkusken hela 14 vinster före tvåan Magnus A Djuse.</p>



<p>I eftermiddagens årsfinal sitter Mats med en hel del starka kort på hand. Han är streckfavorit i tre av sju avdelningar, däribland med Jasmin Ising-tränade trepringen <strong>Lookin At Lucky</strong> (e. Face Time Bourbon) som kommer från imponerande maidenseger på Romme.</p>



<p>Annars dyker spännande fyraåringen <strong>From the Hip</strong> (e. Nuncio) upp i ett flerklasslopp tillsammans med sin tränare Tomas Pettersson. Fem vinster på 13 försök har det blivit i år och nu har Pettersson dragit springspår med sin talang.</p>



<p>Efter eftermiddagens lopp i Bollnäs avslutas året med idel V75 som huvudform. I morgon tar Eskilstuna vid med V75 på uppesittarkvällen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/12/22gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</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/05/highonpepperizoard-617x333.jpg" alt="" class="wp-image-590585"/><figcaption class="wp-element-caption">High On Pepper i ledning varvet från mål i Harper Hanovers lopp med franske Izoard Vedaquais på utsidan. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3Obesegrad i samtliga fem starter under förra vinterns barfotaförbud – totalt åtta raka segrar en period! – och triumfer i Sylvesterloppet och Bergsåker Winter Trot. Svensk mästare och vinnare av Örebro Int’l, tvåa i Harper Hanovers lopp och trea i Åby World Grand Prix under ”sommarsäsongen”.</p>



<p>De vassa resultaten tillhör Katja Melkkos stora stjärna <strong>High On Pepper</strong> (e. Ready Cash), som i Bollnäs för en dryg vecka sedan gjorde comeback efter 2,5 månader tävlingsuppehåll. High On Pepper och Melkkos övriga hästar – 45 finns på träningslistan – flyttade den 1 oktober till Simlom Gård utanför Norrtälje efter att ha haft Julmyra som bas.<br>– High On Pepper fick vila lite när vi flyttade till ny gård, men allt gick precis som planerat och han var fin i sin första start. Nu siktar vi på Sylvesterloppet och allt är väl med hästen, sade Katja Melkko till V65 Direkt.</p>



<p>Sylvesterloppet på Axevalla på nyårsafton är årets sista lopp på svensk mark. Distansen är 2.640 meter och titelförsvararen High On Pepper belastas med 60 meters tillägg.</p>



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



<p class="has-drop-cap">4Monté- och sulkystjärnan <strong>Hanna des Molles</strong> (e. Village Mystic-Ultimate Jet), 1.09,6m*/€1.017.920, lägger tävlingsskorna på hyllan. Hon skulle egentligen startat igår i Grupp II-klassade Prix Jules Lemonnier, men var struken ur loppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/hannadesmollesscoopdyga-617x333.jpg" alt="" class="wp-image-592820"/><figcaption class="wp-element-caption">Hanna des Molles satte nytt världsrekord under sadel – 1.09,6/2.175 meter – tillsammans med Alexandre Abrivard på Vincennes. Foto Scoopdyga</figcaption></figure>



<p>– Hennes knä har besvärat henne i flera månader. För tre veckor sedan röntgade vi henne och den visade varken någon förbättring eller försämring. Den här veckan var hon perfekt fram till i morse (läs fredag morgon, reds. anm.) då hon vid en enkel joggning saknade smidighet. I samförstånd med hennes ägare avslutar vi hennes tävlingskarriär, säger tränaren Laurent-Claude Abrivard till Paris-Turf.</p>



<p>Hanna des Molles vann Grupp I-lopp både framför sulky och sade. Som treåring tog hon hem Criterium des 3 ans (€170.000) och två år senare blev det seger i montéloppet Prix Bilibili (€200.000). Ifjol blev det dubbla Grupp I-segrar under sadel; Prix des Centaures (€240.000) och Prix de l’Ile-de-France (€200.000).</p>



<p>– Jag kommer främst att minnas hennes framgång i Criterium des 3 ans och hennes seger i den första upplagan av Prix Bilibili. Hennes personlighet och vänlighet gjorde Hanna des Molles till en av stallets favoriter.</p>



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



<p class="has-drop-cap">5 Team Alabama HB ropade in den dyraste hästen på Travera igår och för <strong>Buzybee Ravin</strong> (e. Muscle Massive-Superatrix), 1.14,1am/160.043 nok,  betalades 90.000 kronor. Den norskfödde fyraårige valacken har vunnit två av 16 lopp och segrarna har tagits i Vaggeryd och Åmål.</p>



<p>Näst dyrast var kallblodet <strong>Lill Hans</strong> (e. Bork Odin-Samantha Fax), 1.25,0am/627.700 kr, och Jäviesudun Ravipalvelu köpte den sjuårige valacken för 70.000 kronor. Åtta segrar, sex andraplatser och tio tredjepris innehåller karriären på 64 starter.</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 hittar ni här.</a></p>



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



<p class="has-drop-cap">6 Två divisioner i TCT Gold Cup der Tweejarigen (€18.700) hölls i fredags på Victoria Park i Wolwega. Danskfödda <strong>Lust For Life </strong>(e. Mister J.P.-Urban Mesloise) vann den enda avdelningen och det tvååriga stoet kastade loss ute i fjärdespår vid utgången av sista sväng. Enkelt spurtvann hon för Robin Bakker på 1.17,0a/2.100 meter. Tidigare i år har det Paul Hagoort-tränade stoet vunnit ett försök till Dansk Uppfödningslöpning, men var struken ur finalen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/12/skarmavbild20241222kl.05.55.03-617x399.jpg" alt="" class="wp-image-672226"/><figcaption class="wp-element-caption">Lust For Life spurtar till enkel seger för Robin Bakker.</figcaption></figure>



<p>Den andra divisionen gick snabbare och Erwin Bot skötte tömmarna bakom <strong>Paul Schermer </strong>(e. Tactical Landing-Femke Schermer) när han vann på 1.16,5 och räknade in sin tredje seger för säsongen. Tidigare har han vunnit Jonkerprijs (€17.050) och consolation TCT Derby der Tweejarigen (€5.500).</p>



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



<p class="has-drop-cap">7 Svenskfödda <strong>Marion Fouty Bon</strong> (e. Mister J.P.) vann förra lördagen ett försök i Coppa di Milano (€7.040) på San Siro , men slutade oplacerad i finalen. Idag väntar Grupp I-löpningen Gran Premio Royal Mares (€121.000) för fyraåriga och äldre ston på Agnano-banan i Neapel.</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>Stoet som ägs av franska travförbundets ordförande Jean-Pierre Barjon, tränas av Holger Ehlert och Roberto Vecchione tar hand om tömmarna.</p>



<p><strong>Gran Premio Royal Mares</strong> (€121.000)<br>Fyraåriga &#038; äldre ston.<br><em>1.600 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Emma dei Veltri</strong> (e. Maharajah) – Antonio di Nardo</li>



<li><strong>Delicious Gar </strong>(e. Father Patrick) – Alessandro Gocciadoro</li>



<li><strong>Assia Luis </strong>(e. Love You) – Vincenzo P Dell’Annunziata</li>



<li><strong>Dali Prav</strong> (e. Donato Hanover) – Rene’ Legati</li>



<li><strong>Marion Fouty Bon </strong>(e. Mister J.P.) – Roberto Vecchione</li>



<li><strong>Eloida </strong>(e. Napoleon Bar) – Mario Minopoli Jr.</li>



<li><strong>Brezza du Kras</strong> (e. Irving Rivarco) – Gennaro Riccio</li>



<li><strong>Damaris Grif </strong>(e. Mack Grace Sm) – Marco Stefani</li>



<li><strong>Dearrouge</strong> (e. Varenne) – Filippo Gallo</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Två Pd’A-platser i potten
Fem svensktränade hästar i Grupp I-lopp. High On Peppers nästa uppgift. Mats Djuse avslutar snyggt i Bollnäs? Sadel- och sulkystjärna slutar. Svenskfött sto i Grupp I-lopp i Neapel.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
