
<p class="has-drop-cap wp-block-paragraph">1 Jörgen Westholms Vincennes-specialist <strong>Working Class Hero</strong> (e. Village Mystic) har inte kommit med i B-loppen på grund av för låg prissumma och istället får han hålla tillgodo med Prix de Chateaudun (€90.000) på den franska huvudstadsovalen.</p>



<p class="wp-block-paragraph">En start har Working Class Hero gjort under vintermeetinget och det blev seger i Prix de Montignac-Charente (€90.000) på 1.12,2/2.700 meter. Idag på<strong> Vincennes</strong> (första start kl. 13.23) startar han tillsammans med Mathieu Mottier i ett lopp över 2.850 meter. </p>



<p class="wp-block-paragraph">Där går också Daniel Redéns <strong>Indy Rock </strong>(e. Readly Express) ut med Paul-Philippe Ploquin i sulkyn. Han galopperade bort sig i Prix de Blos och gör sitt fjärde framträdande på Paris-ovalen i år. Han har också vunnit lopp, men det skedde i början av februari i Prix de Munich (€90.000).</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Och ännu mer blågult blir det Prix de Briare (€59.000) i ett lopp för sex- till tioåriga travare över distansen 2.700 meter. Sex svenskfödda travare dyker upp i löpningen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/jobspostmedm250628adamstromstalltzedited-617x386.jpg" alt="" class="wp-image-783187"/><figcaption class="wp-element-caption">Jobspost.  Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Det handlar om Jörgen Westholms <strong>Jobspost </strong>(e. Readly Express), Daniel Wäjerstens <strong>Chitchat </strong>(e. Maharajah), Christoffer Erikssons <strong>Humanity Pellini </strong>(e. Up and Quick) och Johan Untersteiners <strong>Mateo di Quattro</strong> (e. Bird Parker). Dessutom startar <strong>Sidney Celeber</strong> (e. Readly Express) och <strong>Mister Invictus </strong>(e. Ready Cash).</p>



<p class="wp-block-paragraph">Senare under dagen får vi se fyra blågula travare i femåringsloppet Prix General du Pommeau (€60.000) över 2.850 meter. Kevin Oscarsson sköter tömmarna bakom <strong>Not For Sale</strong> (e. Readly Express) och i samma lopp starter Daniel Wäjersten <strong>Kingen Mearas </strong>(e. Chapter Seven), men även <strong>Nelson Greenwood</strong> (e. Tobin Kronos) och <strong>Pantocrator</strong> (e. Quarcio du Chene).</p>



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



<p class="has-drop-cap wp-block-paragraph">3 Igår avgjordes det största loppet för tvååriga hingstar – <a href="https://sulkysport.se/kullkung-vann-med-galopp/" data-type="link" data-id="https://sulkysport.se/kullkung-vann-med-galopp/" target="_blank" rel="noreferrer noopener">Prix Emmanuel Margouty</a> – i år i Frankrike och idag är det dags för de jämngamla stona i semi-classique-löpningen Prix Une de Mai (€120.000) över 2.700 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/vourasie1-617x299.jpg" alt="" class="wp-image-796110"/><figcaption class="wp-element-caption">Nacre du Mouthieux vinner för Clément Duvaldestin. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Två obesegrade ston finns med. Thierry Duvaldestin-tränade <strong>Nacre du Mouthieux</strong> (e. Ready Cash) har vunnit samtliga tre starter, varav de två senaste på Vincennes. Största segern hittills är Grupp III-löpningen Prix Vourasie (€60.000) och Clément Duvaldestin sköter tömmarna.</p>



<p class="wp-block-paragraph">William Bigeon-tränade <strong>Not For Fun </strong>(e. Love You) har vunnit båda sina starter och senast Prix Eurynome (€38.000) på den franska huvudstadsovalen.</p>



<p class="wp-block-paragraph">Fältets vinstrikaste travare <strong>Nouba du Bas Bosq</strong> (e. Galius) inledde med fyra raka triumfer, men gick på pumpen (sjua) i senaste starten mot Nacre du Mouthieux.</p>



<p class="wp-block-paragraph"><strong>Prix Une de Mai </strong>(€120.000)<br>Tvååriga ston.<br><em>2.700 meter.</em><br><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Noire Intense</strong> (e. Golden Bridge) – William Bigeon</li>



<li><strong>No Limit Delo</strong> (e. Charly du Noyer) – Benjamin Rochard</li>



<li><strong>Not For Fun</strong> (e. Love You) – Gabriele Gelormini</li>



<li><strong>Norma Jeane </strong>(e. Feeling Cash) – Pierre-Yves Verva</li>



<li><strong>Nova Istoria Choc</strong> (e. Harvest de Buliere) – Benoît Vassard</li>



<li><strong>Nova Tim </strong>(e. Orlando Vici) – Benoît Robin</li>



<li><strong>Nereida</strong> (e. Django Riff) – Franck Nivard</li>



<li><strong>Nymphe d’Elle </strong>(e. Django Riff) – Matthieu Abrivard</li>



<li><strong>Normandie Niemen </strong>(e. Italiano Vero) – David Thomain</li>



<li><strong>Nacre du Mouthieux </strong>(e. Ready Cash) – Clément Duvaldestin</li>



<li><strong>Nanika du Pont</strong> (e. Firello) – Jean-Michel Bazire</li>



<li><strong>Nayara </strong>(e. Village Mystic) – Eric Raffin</li>



<li><strong>Nocive du Choquel</strong> (e. Face Time Bourbon) – Francois Lagadeuc</li>



<li><strong>Nouba du Bas Bosq</strong> (e. Galius) – Yoann Lebourgeois</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/meteoredesimm-617x333.jpg" alt="" class="wp-image-734015"/><figcaption class="wp-element-caption">Meteore de Simm och Mathieu Mottier har tagit hem den franska treåringskullens största montélopp hittills. Foto Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Tre Grupp I-löpningar avgörs också under sadel på den franska huvudstadsovalen. I sadelkriteriet – Prix de Vincennes (€240.000) – startar 13 hästar. Storfavoriten <strong>Meteore de Simm</strong> (e. Boccador de Simm) laddade upp med en sjätteplats i sulkyloppet Prix Pierre Plazen senast, men det är monté som är hans specialitet.</p>



<p class="wp-block-paragraph">Han har vunnit samtliga sex sadellopp i karriären och däribland Grupp I-klassade Prix d’Essai (€200.000), men också tre semi-classique-löpningar; Prix Felicien Gauvreau, Prix Gai Brillant och Prix Louis Tillaye.</p>



<p class="wp-block-paragraph"><strong>Prix de Vincennes</strong> (€240.000)<br>Treåringar – monté.<br><em>2.700 meter.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Ryttare</strong></p>



<ol class="wp-block-list">
<li><strong>Marion d’Hafling</strong> (e. Unbridled Charm) – Paul-Philippe Ploquin</li>



<li><strong>Mojito Fraise</strong> (e. Bird Parker) – Benjamin Rochard</li>



<li><strong>Miratissime</strong> (e. Brillantissime) – Arthur Rebeche</li>



<li><strong>Moustik La Govelle</strong> (e. Discours Joyeux) – Damien Bonne</li>



<li><strong>Milord de la Vallee</strong> (e. Captain Sparrow) – Eric Raffin</li>



<li><strong>Memphis de Brasse</strong> (e. Gotland) – Francois Lagdeuc</li>



<li><strong>Manitas de Truchon</strong> (e. Etonnant) – Mathis Champenois</li>



<li><strong>Melody de Vivoin</strong> (e. Seigneur Aimef) – Jean-Yann Ricart</li>



<li><strong>Matignon </strong>(e. Bird Parker) – Alexandre Abrivard</li>



<li><strong>Miss des Besaces</strong> (e. Memphis du Rib) – Alan Gendrot</li>



<li><strong>Mademoiselle Jane</strong> (e. Ready Cash) – Adrien Lamy</li>



<li><strong>Mhum Flyng</strong> (e. Helgafell) – Victor Saussaye</li>



<li><strong>Meteore de Simm</strong> (e. Boccador de Simm) – Mathieu Mottier</li>
</ol>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2025-12-14/7500" data-type="link" data-id="https://www.letrot.com/courses/programme/2025-12-14/7500" target="_blank" rel="noreferrer noopener">Startlistorna till Prix Jag de Bellouet (€200.000) och Prix Bilibili (€200.000) för fyra- respektive femåringar och där det står två biljetter till Prix de Cornulier (€700.000) hittar ni här plus alla andra löpningar i Paris.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/mattiasdjuse-617x333.jpg" alt="" class="wp-image-656381"/><figcaption class="wp-element-caption">Mattias Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4 Mattias Djuse hade ett rekordår 2024 med 153 segrar och 21.948.730 kronor till stallet. Med drygt två veckor kvar av 2025 har han en bit upp till de siffrorna, men med 119 segrar och nästan 20,3 miljoner inkört ligger han inte långt efter.</p>



<p class="wp-block-paragraph">Till tävlingarna på söndagens enda svenska bana i elden <strong>Eskilstuna</strong> (första start 13.45) har Solvallatränare Djuse laddat friskt. Sex av stallets hästar ska tävla och flera av dem med goda segerchanser på förhand. Inom söndagsspelet Grand Slam 75 tränar han exempelvis fyra av sju streckfavoriter på förhand!<br>En av dem är treåriga <strong>My Precious One</strong> (e. Readly Express), som ståtar med två raka segrar, där den senaste togs för knappt två veckor sedan just i Eskilstuna.</p>



<p class="wp-block-paragraph">Det bjuds även final i Travföreningens kuskserie, där Mats Gunnarsson sitter med trumf på hand när han kör Philip di Luca-tränade <strong>Tangelo</strong> (e. Explosive Matter). Tillsammans har duon redan vunnit tre lopp i år på elva försök.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/12/14gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5 En ostartad tvåårig valack –<strong> Fear the Dragon</strong> (e. S.J.’s Caviar-Global Bitcoin) – från Maria Törnqvists stall blev dyrast på Travera igår och Ove Holmgren Fastighetsservice AB hade högsta budet. Klubban slogs på 250.000 kronor för första avkomman undan <strong>Global Bitcon </strong>(e. Brillantissime), 1.13,7ak/188.000 kr.</p>



<p class="wp-block-paragraph"><strong>Finn Palema</strong> (e. Muscle Hill-Fillyanthropy), 1.09,5ak/1.117.187 kr, var näst dyrast. Solvallatränaren Anders Eriksson betalade 200.000 kronor för den sexårige hingsten som vunnit sju lopp på 41 starter.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/auktionsresultat/" target="_blank" rel="noreferrer noopener">Samtliga resultat från Travera-auktionen igår hittar ni här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Hanna Olofsson gjorde en framgångsrik avstickare till finska Uleåborg igår. Hon startade tre hästar och vände hem med två segrar. Detta sedan hon själv lotsat <strong>Jimmy Adore</strong> (e. Explosive Matter) och <strong>Borndownunder</strong> (e. Flocki d’Aurcy) till varsin vinst.<br>Jimmy Adore fick största prischecken – 4.000 euro – när han vann från ledningen i överlägsen stil på 1.14,8a/2.120 meter.</p>



<p class="wp-block-paragraph">Tävlingsdagens största lopp var finalen i tre- och fyraåringsloppet Ponsse Cup med 12.000 euro till vinnaren. Två svensktränade hade kvalat in, men Jens Erikssons treåring Hällebackens Nike (e. Sebastian K.) gjorde en slät figur från tredje utvändigt och Mats Rånlund-tränade Ynnest Lloyd (e. Quick Wood) ströks.</p>



<p class="wp-block-paragraph">Loppet bjöd på en imponerande vinnare i fyraårige <strong>Green River’s Zack</strong> (e. Jontte Boy), som stod pall hela vägen efter att ha öppnat 1.12,5 första kilometern i ledning i medeldistansloppet. Hannu Torvinen körde hästen som tränas av Kari Lehtonen och nu har tjänat knappt 30.000 euro. Vinnartiden skrevs till 1.14,4a/2.120 meter.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Franska travförbundet meddelar att det primära målet 2026 är att kunna behålla nivån på prispengar och incitament. Styrelsen berättar om att det blir ett litet överskott för 2025, men också att franska travförbundet ska fortsätta sitt arbete med olika kostnadsbesparande åtgärder som ska genomföras från och med 2026.</p>



<p class="wp-block-paragraph">Spelet hos PMU backar för andra året i rad och en återhämtningsplan kräver investeringar inom PMU och moderbolagen – travet och galoppen – saknar möjlighet att finansiera detta för egen del.</p>
