
<p class="has-drop-cap">1Det tävlas totalt om 1.215.000 euro i de tio loppen vid dagens tävlingar på Vincennes (första start kl. 13.23), som fick en rejäl nivåhöjning förra året och har växt ytterligare i år med ett extra lopp. Prix de Luxembourg (€100.000) – se nedan – finns alltjämt kvar som en av godbitarna, men numera är det två Grupp I-lopp som är de absoluta höjdpunkterna.</p>



<p>Svenska hopp finns när femåringarna gör upp i Prix Bold Eagle (€300.000) när Sabine Kagebrant plockar ut jänkaren <strong>Kilmister</strong> (e. Chapter Seven), som inte fått till det på fransk mark hittills, och Fredrik Wallin mönstrar <strong>Immortal Doc</strong> (e. Brillantissime). Denne var duktig tvåa i Prix de Croix (€120.000) i senaste starten. Även Erwin Bots svenskfödda toppsto <strong>Ninetta Boko</strong> (e. Father Patrick), medan Björn Goop sitter upp bakom Alessandro Gocciadoros East Asia (e. Ready Cash).<br>Loppets mest meriterade häst är euromiljonären <strong>Koctel du Dain</strong> (e. Biccador de Simm, som tränaren Philippe Allaire kunde plockat ut i Prix d’Amérique, men valde detta lopp i stället.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/immortaldoc-617x333.jpg" alt="" class="wp-image-507547"/><figcaption class="wp-element-caption">Fredrik Wallin-tränade Immortal Doc. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>I fyraåringarnas Prix Ourasi (€300.000) gör forne svenske Uppfödningsvinnaren <strong>L&#8217;Amourpourblanca</strong> (e. Face Time Bourbon) tredje starten i Fabrice Souloys regi efter att ha inlett med två niondeplatser.<br>De mest meriterade motståndarna är tätduon i italienska <strong>Derbyt First Of Mind</strong> (e. Face Time Bourbon) och <strong>Frank Gio</strong> (e. Face Time Bourbon) tillsammans med franska toppduon i Criterium des 3 Ans: ettan <strong>Lovino Bello</strong> (e. Village Mystic), som närmast triumferade i grupp I-loppet Prix Ready Cash, och tvåan <strong>Lombok Jiel</strong> (e. Enino du Pommereux).</p>



<p>Detta kryddas med Grupp II-klassade Prix Rocquepine (€150.000) för treåriga ston och Prix Paul Viel (€150.000) för treåriga hingstar, båda loppen över 2.700 meter, dock utan svenskar.</p>



<p>Totalt startar nio svenskfödda hästar på Vincennes på lördagen. Johan Untersteiner tar ut <strong>Behind Bars (</strong>e. Maharajah) i Prix de Vittel (€68.000) över 2.700 meter.</p>



<p>I Prix de Chalons En Champagne (€40.000) för fyraåriga ston är blott fyra av 15 (!) hästar franskfödda. Björn Goop Frankrikedebuterar Menhammaruppfödningen <strong>Gosa Gosing</strong> (e. Readly Express), som var trea i försök till Svenskt Trav-Oaks i höstas. Även svenskfödda <strong>Queen Of Paris</strong> (e. Mister J.P.) startar.</p>



<p>Internationella amatörloppet Coupe Intercontinentale des Amateurs (€15.000) inleder tävlingsdagen. Mats Gunnarsson representerar Sverige och kör åttaåriga stoet <strong>Hillona de Nesle</strong> (e. Boccador de Simm), 1.13,2/€133.920, från spår fyra bakom bilen.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-01-25/" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens stortävlingar på Vincennes.</a></p>



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



<p class="has-drop-cap">2 …och på tal om Prix du Luxembourg (€100.000). Loppet är en uppvärmare för den äldre eliten inför det stora slaget i morgon på Vincennes och har haft en del blågul prägel genom åren och bland annat sett sju svenskfödda travare skära mållinjen som vinnare, men det är tio år sedan förra gången när Hans R Strömbergs <strong>On Track Piraten</strong> (e. Kool du Caux) segrade med nye domarbasen Erik Adielsson i vagnen.</p>



<p>Årets upplaga är som så många gånger tidigare fyllt av svenska inslag. Fyra svenskfödda travare, varav tre svensktränade, tar plats bakom startbilen i fartfesten över 2.100 meter. </p>



<p>Daniel Redén mönstrar en duo i <strong>Mister Hercules</strong> (e. Trixton) och Brambling (e. Bold Eagle), där den förstnämnde drog spår två, medan <strong>Brambling</strong> (e. Bold Eagle) inleder från spår 14. Yoann Lebourgeois respektive Björn Goop kör hästarna. Fredrik Wallin har fältets ”fattigaste” häst i <strong>Global Etalon</strong> (e. Brillantissime), som får David Thomain i vagnen.<br>Norrmannen Kristian Malmin hade Pd’A-planer för svenske <strong>Oracle Tile</strong> (e. Ready Cash), men pengarna räckte inte. Istället blir det start här från spår nio med Benjamin Rochard i vagnen.</p>



<p>I startfältet finns också Alessandro Gocciadoros vinnare av Oslo Grand Prix i somras, <strong>Banderas Bi</strong> (e. Ganymede), och fjolårsvinnaren Face Time (e. Coktail Jet). Denne tog sex raka segrar på Vincennes förra vintern, men har efter långt uppehåll bara en sjundeplats som bäst på tre försök det här meetinget i regi Matthieu Abrivard.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/01/facetimeluxembourg-617x333.jpg" alt="" class="wp-image-546464"/><figcaption class="wp-element-caption">Matthieu Abrivard-tränade Face Time vann Prix du Luxembourg tillsammans med Gabriele Gelormini med Daniel Redéns Missle Hill (9) som trea och Daniel Wäjerstens Dear Friend (5) som femma. Foto Scoopdyga</figcaption></figure>



<p><strong>Svenskfödda vinnare i Prix du Luxembourg</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>1985<strong> Pay Me Quick</strong> (e. Quick Pay) – Stig H Johansson – 1.15,6a</li>



<li>1991 <strong>Mr Lucken</strong> (e. Able Mission) – Torbjörn Jansson – 1.14,3a</li>



<li>1995 <strong>Activity</strong> (e. Active Bowler) – Anders Lindqvist (Bengt Hansson) – 1.13,9a</li>



<li>2002 <strong>Egon Lavec</strong> (e. Navaki) – Lutfi Kolgjini – 1.13,2</li>



<li>2008 <strong>Improve Ås</strong> (e. Tagliabue) – Franck Nivard (Fabrice Souloy) – 1.11,5a</li>



<li>2012 <strong>Yarrah Boko</strong> (e. Coktail Jet) – Franck Nivard (Trond Anderssen) – 1.11,5a</li>



<li>2015 <strong>On Track Piraten</strong> (e. Kool du Caux) – Erik Adielsson (Hans R Strömberg) – 1.12,2a</li>
</ul>



<p><em>*  Den vanligaste distansen är 2.100 meter autostart, men under några år 1987–1991 avgjordes loppet över den engelska milen.</em></p>



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



<p class="has-drop-cap">3Romme (första start 14.45) dukar upp för V75 i skymundan av storhelgen i Paris. Sulkysports tipsexpert har plockat ut två spikar på V75 – och det låter positivt om båda:<br>– <strong>Noutcha di Quattro</strong> (V75-1) har väldigt bra form och har gått bra på sistone. Jag hoppas att hon kan utnyttja spåret bra (springspår, reds. anm.) och känslan är att hon kan kan kliva iväg rätt hyggligt. Hon står sig fortsatt väldigt bra i klassen och det är inget som oroar att hon har sprungit på sig mycket pengar, sade Magnus A Djuse till V65 Direkt. <br>– <strong>High On Pepper</strong> (V75-3) känns jättefin här hemma, han är pigg och glad och tränar normalt. Hästen klarar normalt alla typer av banor, men på Axevalla (när High On Pepper inte fick det att flyta och galopperade i slutsvängen, reds. anm.) var det jättedjup sand och det sade Jorma redan efter värmningen, sade Katja Melkko till V65 Direkt.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-8/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång till Romme med analyser, spikar och drag. </a></p>



<p>Hos vår samarbetspartner Travnet finns andelar till dagens V75-omgång på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V75_2025-01-25_23_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</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/2022/09/hannaolofssonsulky-617x333.jpg" alt="" class="wp-image-357271"/><figcaption class="wp-element-caption">Hanna Olofsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4Det blir minst sagt svensktätt i högsta klassen med 6.000 euro i förstapris i finska Uleåborg i eftermiddag. Hela fem av tolv hästar i loppet är tränare i Sverige!</p>



<p>Hanna Olofsson reser till Finland med fem hästar och i det aktuella loppet kör hon segermaskinen <strong>Last Dying Breath</strong> (e. Nuncio). Denne var trea i Bodens framflyttade tävlingar i tisdags bakom Devils Tongue och Selmer I.H. och får sällskap i loppet av stallkamraten <strong>Humble Stance</strong> (e. Repeat Love), som startade så sent som i torsdags lunch i Skellefteå.</p>



<p>En duo har även Bert Pettersson i loppet i form av <strong>Bravo Sabotage</strong> (e. From Above) och <strong>Marciano</strong> (e. Muscle Hill), som båda gör årsdebut. Det femte blågula kortet kommer från Sandra Erikssons stall i form av <strong>King Of Djazz</strong> (e. Zola Boko).</p>



<p>Hanna Olofssons övriga starthästar i Uleåborg är <strong>Sensitive Tile</strong> (e. Trixton), <strong>Hotspot Simoni</strong> (e. Raja Mirchi) och <strong>Henessi Walk</strong> (e. Walk The Walk). I den sistnämndes lopp startar även Sandra Eriksson <strong>B.Sacamano</strong> (e. Prodigious).</p>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5PXzI1LjAxLjIwMjUucGRm&#038;m=TPK%2FiP63M4w1Y4FnvB5ArCkhpKQ%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Uleåborgs tävlingar.</a></p>



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



<p class="has-drop-cap">5Snart är det dags för Australiens största löpning – Great Southern Star ($250.000) – och idag är det generalrepetition i V.L. Dullard Trotters Cup ($30.000) på Melton. Favorit till segern är <strong>Keayang Chucky</strong> (e. Love You), 1.11,5*/$277.030, trots att den sjuårige valacken dragit bakspår. Det har också andrahandsfavoriten <strong>Queen Elida</strong> (e. Love You), 1.10,2*/$945.195, som vunnit 36 av 78 starter.</p>



<p>Efter dagens lopp väntar försök ($20.000) och final i Great Southern Star på Melton den 1 februari. Veckan efter – den 8 februari – körs Cranbourne Trotters Cup ($50.000) och den 22 februari bjuds på Australian Trotting Championship ($50.000) på Melton. </p>



<p><strong>V.L. Dullard Trotters Cup ($30.000)</strong><br>Äldre hästar, 2.240 meter, autostart. <br><em>Namn (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Illawong Stardust (e. Muscle Hill) – Sean O’Sullivan</li>



<li>Ebonys Avenger (e. Kvintet Avenger) – Jordan Leedham </li>



<li>Kyvalleyhoneybunny (e. Skyvalley) – Tristan Larsen</li>



<li>Kings Guard (e. Love You) – Stephen Boyington</li>



<li>Illawong Larajay (e. Sebastian K.) – Greg Sugars</li>



<li>Nephew of Sonoko (e. Danny Bouchea) – James Herbertson</li>



<li>Brandlo Prince (e. Orlando Vici) – Ross Payne</li>



<li>Lovemeto (e. What the Hill) – Chris Svanosio</li>



<li>Sundons Courage (e. Sundon) – Ryan Duffy</li>



<li>Aardiebythehill (e. Muscle Hill) – Ewa Justice</li>



<li>Mufasa Metro (e. Father Patrick) – John Justice</li>



<li>Queen Elida (e. Love You) – Chris Alford</li>



<li>Keayang Chucky (e. Love You) – Jason Lee</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/01/jrvsfaksihagen-617x288.jpg" alt="Sulkysport, Travsport, Trav, Häst, Järvsöfaks" class="wp-image-17802"/><figcaption class="wp-element-caption">Järvsöfaks. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">6Championhingsten och avelsnestorn <strong>Troll Jahn</strong> (född 1971 e. Jahn Sjur-Grans Turi) vann själv 89 av 236 starter och sprang in 521.178 norska kronor på 1970- och 1980-talet. I avelsboxen gjorde han än större avtryck och utsågs 1995 till Elithingst efter att ha varit champion i Norge fem år, 1990-1994, och satte sedan stora avtryck i svensk avel. Framför allt som farfar till en viss Järvsöfaks…<br>Hingsten kördes oftast av Leangentränaren Björn Garberg och ikväll på Varig Orkla Arena några mil söder om Trondheim är det dags för tredje upplagan av Troll Jahns Äreslopp på den nya banan, som tog vid när Leangen gick i graven vintern 2022.</p>



<p><strong>Järvsöfaks</strong> (e. Trollfaks e. Troll Jahn) vann själv loppet både 2001 och 2002 och de senaste tre årens vinnare finns med i startfältet nu. Det handlar om Jomar Blekkans <strong>Alma Prins</strong> (e. Tekno Odin), som jagar från 40 meters tillägg över grunddistansen 2.300 meter. Alma Prins har vunnit hela 54 lopp på 129 starter hittills i karriären.</p>



<p>En svensk tränare gör resan till Orkla. Östersunds Thommy Enberg kör egentränade <strong>Caliber af Teda</strong> (e. El Mago Pellini), som årsdebuterar i DNT:s 150-årsjubileumslopp med 70.000 kronor till vinnaren. Caliber af Teda avslutade fjolåret med två raka segrar.</p>



<p>Norrmännen spelar till dubbla V75-omgångar idag – både Romme och Orkla – och norska banan tar vid ikväll.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/01/oa20250125baneprogram.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Orklas tävlingar.</a></p>



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



<p class="has-drop-cap">7STL-finalvinnaren <strong>Ringo Adore</strong> (e. Trixton), 1.12,2ak*/857.500 kr, är en av 14 starthästar som bjuds ut på kvällens sedvanliga internetauktion hos Travera. Den n yblivne sexåringen har vunnit sex lopp hittills i karriären och de två senaste säsongerna sprungit in 800.000 kronor.<br>Ett treårigt sto, <strong>Eigth Days Ahead</strong> (e. Traders), som nyligen kvalade finns också i kategorin starthästar.</p>



<p>På avelssidan finns sex fölston och betäckning 2025 i avelshingstarna <strong>Brillantissime</strong> och <strong>Trixton</strong> till försäljning. Två av fölstona är dräktiga och där ingår levande föl-avgift för <strong>Ecurie D. </strong>respektive <strong>Flocki d’Aurcy</strong>.</p>



<p><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som säljs och följa budgivningen under kvällen.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Uppvärmning – 14 miljoner i potten
Dunderlördag värmer upp inför Prix d’Amérique. Svenskar slåss om storpotter. Här är bästa spikarna på Rommes V75. Blågula drar till Finland. Hyllning till Järvsöfaks farfar.
Detta och mer i dagens nyhetssvep.
Detta och mer i dagens nyhetssvep.
