
<p class="has-drop-cap">1Han blev den förste fyraåringen på 13 år att segra i gulddivisionen när han besegrade <strong>Önas Prince</strong> (e. Chocolatier) på hemmabanan Halmstad i slutet av förra året. Nu har Johan Untersteiner-tränade <strong>Stens Rubin</strong> (e. Readly Express) fyllt fem år och på Jägersro på lördag ska han försöka inleda ”seniorkarriären” med ny triumf i rikstotons högsta klass.</p>



<p>Stens Rubin är en av tio hästar i Arvid Stjernswärds Minneslöpning på Jägersro på lördag och i just det loppet skev Sören Nordins styrkefenomen <strong>Mustard</strong> (e. Tibur) historia. Redan den 15 mars under fyraåringssäsongen (1980) vann nämligen Mustard mot det rutinerade gardet i gulddivisionen. Det var hästens första av tre guldsegrar som fyråring!</p>



<p>Däremot får inte årets upplaga plats på V75-kupongen när det är jackpot på Jägersro. Det har nämligen lagts i början av tävlingsdagen innan det stora streckspelt drar igång.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/01/18v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Jägersros tävlingar på lördag.</a></p>



<p><strong>Fyraåringar som vunnit gulddivisionen:</strong><br><em>År (datum) – Namn (far) – Körsven/tränare</em></p>



<ul class="wp-block-list">
<li>1974 (16/11) – <strong>Grain</strong> (e. Cahoot) – Stig H Johansson</li>



<li>1974 (23/11) – <strong>Grain </strong>(e. Cahoot) – Stig H Johansson</li>



<li>1980 (15/3) – <strong>Mustard</strong> (e. Tibur) – Sören Nordin</li>



<li>1980 (29/3) – <strong>Mustard</strong> (e. Tibur) – Sören Nordin</li>



<li>1980 (26/10) – <strong>Mustard</strong> (e. Tibur) – Jan Nordin/Sören Nordin</li>



<li>1987 (12/10) – <strong>Lord Quick</strong> (e. Quick Pay) – Mats Rånlund</li>



<li>2002 (7/9) – <strong>Scarlet Knight</strong> (e. Pine Chip) – Stefan Melander</li>



<li>2011 (3/12) – <strong>Amaru Boko</strong> (e. Coktail Jet) – Jorma Kontio/Timo Nurmos</li>



<li>2024 (28/12) – <strong>Stens Rubin</strong> (e. Readly Express) – Johan Untersteiner</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/12/00264122041scoopdyga-617x411.jpg" alt="" class="wp-image-673629"/><figcaption class="wp-element-caption">Mellan hästar vinner Beautiful Day och Benjamin Rochard före utvändige Chitchat och invändige Chestnut. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap">2Det blir svensktätt på Vincennes (första start 13.55) i eftermiddag. Hela åtta svenskfödda travare dyker upp i de två europeiska loppen på kolstybben och totalt selar sex svenska tränar ut hästar.</p>



<p>Inledningsloppet Prix de Brionne (€52.000) över 2.850 meter ser Daniel Wäjerstens duo <strong>Chitchat</strong> (e. Maharajah) och <strong>H.C.Crazy Horse</strong> (e. S.J.’s Caviar) mot Björn Goops <strong>Heartbeat Thunder</strong> (e. Scarlet Knight), Daniel Redéns <strong>Chestnut</strong> (e. Jocose) och Fredrik Wallin-tränade <strong>Reven Dejavu</strong> (e. Revenue).<br>Samtliga fem hästar är svenskfödda och bäst i vinter har Chitchat lyckats när han slutade tvåa på Vincennes i mellandagarna. Wäjersten kör själv hästen. Chestnut har dubbla tredjeplatser på tre starter.</p>



<p>Constanza Flores och Jonathan Carre gör en Frankrikesatsning och första starthästen från stallet är Jolicoeur (e. Atlas de Joudes) i sulkyloppet Prix de Pont-Audemer (€41.000) för sexåringar. Mathieu Mottier kör hästen som bland annat ställs mot svenskfödda duon Modric Renka (e. Donato Hanover) och Frankrikedebutanten Mister Jupiter (e. Ready Cash). Den sistnämnde vann Kriteriekval 2022 i Timo Nurmos regi och tränas numera av Jocelyn Robert.</p>



<p>Björn Goop plockar ut franska stoet Liberty Avenue (e. Fabulous Wood) i Prix de Feneu (€40.000), där Franck Ouvrie sitter i vagnen, medan Jarmo Niskanen startar Lady Godiva (e. Real de Lou) i sadelloppet Prix de Bayonne (€35.000). Sverigebekantingen Ron Kuiper provar Marie Jose Labelle (e. Alto de Viette) i Prix d’Ableiges (€33.000). </p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-01-14/" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Vincennes.</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/2021/06/anderseriksson-617x333.jpg" alt="" class="wp-image-182657"/><figcaption class="wp-element-caption">Anders Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3Anders Eriksson hade sitt hittills bästa år som proffstränare 2024 när han klev över två miljoner kronor till stallet. Det nya året öppnades på bästa sätt med seger för <strong>Heavenly Laday</strong> (e. Readly Express) i Gävletravets årspremiöär för en dryg vecka sedan.</p>



<p>Ikväll är Gävle (första start 18.20) huvudbana på svensk mark och Solvallatränaren reser norrut med en duo. Kapable <strong>Sparky&#8217;s Dream</strong> (e. Maharajah) har matchats en hel del inom rikstoton, men största segern kom i slutet av sommaren förra året när han vann Dam-SM tillsammans med Agnes Larsson.<br>Nu sitter som oftast tränaren i vagnen när Sparky&#8217;s Dream jagar andra raka segern. Spår fyra bakom bilen och sprinterdistans är förutsättningarna i Gävle ikväll. </p>



<p>Anders har även med sig <strong>Bjorn</strong> (e. Panne de Moteur) i en spårtrappa, där sjuåringen gör comeback efter nästan sju månaders tävlingsfrånvaro. Fyra segrar och tre andrapris har det blivit för Bjorn vars karriär stoppats upp av skadeavbrott. </p>



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



<p class="has-drop-cap">4Markus B Svedberg lade beslag på titeln årets tränare när Sundbyholm hade travgala i lördagskväll, medan Per Lennartsson utsågs till årets kusk. Svante Ericssons <strong>Phoenix Photo</strong> (e. Super Photo Kosmos) blev Årets Häst efter att ha sprungit in nästan 1,5 miljoner kronor som tioåring.</p>



<p>Idag drar Eskilstuna (första start 12.20) igång tävlandet på svensk mark med lunchlopp och både Svedberg och Lennartsson är i elden.<br>En delningsproposion stängd vid halvmiljonen intjänat och för hästen med högst 1.000 startpoäng står på menyn. 112 hästar anmäldes och 84 får chansen att tävla i spårtrapporna.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/01/250114.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens 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/2021/04/doctordoxeyzenz-617x333.jpg" alt="" class="wp-image-147258"/><figcaption class="wp-element-caption">Doctor Doxey Zenz och Mathias Andersson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">5Första starten på 15 månader. På fredag på Färjestad är Mathias Andersson-tränade tolvåringen <strong>Doctor Dozey Zenz</strong> (e. Donato Hanover) tillbaka på tävlingsbanan.<br>Bland motståndarna finns ett år yngre <strong>Milliondollarrhyme</strong> (e. Ready Cash). Den niofaldige miljonären går in på sin nionde säsong på tävlingsbanan och har vunnit 19 av 119 starter så här långt.<br>Än värre är faktiskt Åke Lindbloms startblixt <strong>Chapuy</strong> (e. Quite Easy), som inledde sin framgångsrika karriär med fyra starter som tvååring 2016 och nu är redo för säsong tio.</p>



<p><strong>Startlista snabblopp, Färjestad fredag:</strong><br>2.140 meter autostart, förstapris 35.000 kr.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Love You Too (e. Love You) – Carl Johan jepson (Erik Andersson)</li>



<li>Sheena’s Boy (e. Trixton) – Ole Johan Östre (Thor Borg)</li>



<li>Filippa B.J. (e. Muscle Mass) – Jorma Kontio (Sybille Tinter)</li>



<li>Milliondollarrhyme (e. Ready Cash) – Björn Goop (Fredrik B Larsson)</li>



<li>Doctor Doxey Zenz (e. Donato Hanover) – Mathias Andersson</li>



<li>Dark Roadster (e. Super Photo Kosmos) – Andreas Peterson (Emma-Sara Sjöberg)</li>



<li>Chapuy (e. Quite Easy) – Åke Lindblom</li>



<li>Pretty Devil (e. Pastor Stephen) – Eiri Höitomt (Thor Borg)</li>
</ol>



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



<p class="has-drop-cap">6När storhästägaren Lennart Ågren – Srf Stable – ropade in danske <strong>Godfather</strong> (e. Bold Eagle), 1.12,7ak/336.171 dkr, för 1,1 miljoner danska kronor 2019 blev det den dyraste ettåringen genom tiderna på dansk auktion.<br>Godfather lovade också en hel del på tävlingsbanan i Ola Samuelssons regi, där han var tvåa i danska Kriteriet för fyra år sedan.</p>



<p>För drygt ett år sedan såldes en då femårig Godfather på Travera för 130.000 kronor och i söndags var han uppe i ”internetringen” igen. På Selected Sales auktion Breeders Sale fann Godfather nya ägare i Nederländerna när Martin Lukje klickade hem hästen. 5.250 euro blev budet, rapporterar danska Travservice.</p>



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



<p class="has-drop-cap">7Sugen på att göra som <strong>Järvsöfaks</strong> och flera andra svenska hästar? Nämligen att vinna en norsk kallblodsklassiker? Den 31 januari går anmälningstiden ut till norska Derbyt och Kriteriet 2027 för kallblod.</p>



<p>För Derbyt gäller det alltså hästar födda 2023, medan Kriteriet handlar om kallblod födda 2024.<br>Anmälan går att gör via användarkontot hos Svensk Travsport, skriver travförbundet på sin hemsida.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Historisk häst i historiskt lopp
Ovanlig guldvinnare jagar ny triumf. Svenskmatchen på Vincennes. Fyller på mot nytt rekordår? Årets tränare redo på hemmaplan. Danmarks dyraste ettåring såld igen.
Detta och mer i tisdagens nyhetssvep.
Detta och mer i tisdagens nyhetssvep.
