
<p class="has-drop-cap wp-block-paragraph">1Sören Nordins Derbyvinnare <strong>Mustard</strong> (e. Tibur) var förste svenskfödde hästen att tjäna över en miljon kronor under fyraåringssäsongen. I lördags blev Jörgen Westholms trefaldige storloppsvinnare <strong>Dream Mine</strong> (e. Maharajah) den vinstrikaste fyraåringen – tränad på svensk mark – under ett år när han via segern i Breeders Crown-finalen klev upp i 9.179.500 kronor.<br>Dream Mine har behövt tio starter (8-1-1) för att slå <strong>Francesco Zets</strong> (e. Father Patrick) felfria säsong 2022 med nio vinster på lika många starter.</p>



<p class="wp-block-paragraph">En svenskfödd häst har faktiskt klivit över tio miljoner kronor, det i USA tränade stoet <strong>Jiggy Jog</strong> (e. Walner), som i Åke Svanstedts regi travade ihop 10.654.867 kronor för två år sedan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/francescozet22-617x333.jpg" alt="" class="wp-image-389101"/><figcaption class="wp-element-caption">Francesco Zet och Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Vinstrikaste svenska fyraåringar</h2>



<p class="wp-block-paragraph"><em>År, häst – Kön/härstamning – Prispengar (kr)</em></p>



<ul class="wp-block-list">
<li>2025: <strong>Dream Mine</strong> – h e. Maharajah-Your Dreamgirl – 9.179.500</li>



<li>2022: <strong>Francesco Zet</strong> – h e. Father Patrick-Shaqline – 9.000.000</li>



<li>2017: <strong>Cyber Lane</strong> – v e. Raja Mirchi-Sybaris Hanover – 6.935.500</li>



<li>2021: <strong>Önas Prince</strong> – h e. Chocolatier-Sobra – 6.880.500</li>



<li>2020: <strong>Hail Mary</strong> – h e. Googoo Gaagaa-Dreams U.S. – 6.877.500</li>



<li>1993:<strong> Ina Scot</strong> – s e. Allen Hanover-Lovina Grefgård – 6.861.000</li>



<li>2021: <strong>Calgary Games</strong> – h e. Readly Express-Olympia Tilly – 6.480.000</li>



<li>2023: <strong>Joviality</strong> – s e. Chapter Seven-Pasithea Face – 6.314.500</li>



<li>2018: <strong>Mellby Free</strong> – s e. Muscle Hill-Mellby Ticket – 6.105.830</li>



<li>1997: <strong>Kramer Boy</strong> – h e. Sugarcane Hanover-Traffic Jam – 5.932.840</li>
</ul>



<p class="wp-block-paragraph"><em>Listan gäller hästar i svensk träning i Sverige.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">2Den 21 oktober blev danske topptränaren Michael Lönborg av med sin tränarlicens med omedelbar verkan och han fick inte heller vistas på några travbanor och anläggningar, knutna till det danska travförbundet. Detta sedan Lönborg dömts till 14 dagars villkorligt fängelse och böter för sexuellt ofredande.</p>



<p class="wp-block-paragraph">Nu har han överklagat domen till danska travsportens överdomstol, skriver danska travsajten Travservice.<br>– Det är min advokat som rådde mig att överklaga domen till överdomstolen. Advokaten anser att straffet är alldeles för hårt jämfört med det straff jag fick i tingsrätten, och vi vill därför att löbsdomstolen ska bedöma detta, säger Michael Lönborg till <a href="http://travservice.dk">travservice.dk</a>.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Tisdagens högst doterade lopp på svensk mark avgörs på kvällsbanan Bergsåker (första start 18.00), där tio treåriga kallblod tävlar om 100.000 kronor i förstapris i Svensk Travsports Treåringslopp.</p>



<p class="wp-block-paragraph">De tyngsta meriterna har Robert Skoglund-tränade hingsten <strong>Ängsrask</strong> (e. Bork Odin), som snart kan summera en fin debutsäsong på tävlingsbanan. Fyra segrar, ytterligare fyra pallplatser och 713.692 kronor på kontot. Där ryms andraplatsen i svenska Kriteriet, bronsplatsen i den norska upplagan och i senaste starten segern i finalen av Norrlands Elitserie för treåringar. <br>Nu väntar 40 meters tillägg, men kapacitetsmässigt talar mycket för att Ängsrask lägger en ny sexsiffrig check till meritlistan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/hulteadam-617x333.jpg" alt="" class="wp-image-752948"/><figcaption class="wp-element-caption">Hulte Adam och Henrik Kihle. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">De fyraåriga kallbloden tävlar om halva summan i ett litet men naggande gott fält med miljonärerna <strong>Trollbackens Olov</strong> (e. Odin Tabac), <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn) och årets främsta svenska fyraåring på hingstsidan, Jan-Olov Persson-tränade <strong>Hulte Adam</strong> (e. Hulte Magnus).<br>Denne har sprungit in 765.788 kronor i år och den summan straffas bara av Jerker Bjurmans sto <strong>M.P.Flora</strong> (e. Tekno Odin) med 834.012 kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Björn Norén har många strängar på sin lyra i travvärlden. Som manager för Knutsson Trotting, styrelseledamot i Västergötlands Travsällskap, gästexpert i ATG Live – och amatörtränare med tre hästar på sin träningslista.</p>



<p class="wp-block-paragraph">Det klarast lysande namnet i stallet är USA-födde <strong>Hipster K.</strong> (e. Sebastian K.), som kom till Sverige och ”Bernie” våren 2021. Det har varit en del upp och ner, men på plussidan finns rikstotoseger både 2023 och 2024, båda gångerna i Örebros aprilomgång.<br>I våras var han tillbaka på banan efter längre uppehåll, men längre än till seger i ett P21-lopp har han inte kommit. Ännu, vill säga. </p>



<p class="wp-block-paragraph">Idag på lunchbanan Åby (första start 12.20) har hästen sina drömförutsättningar med sprinterdistans, startbil och spetsläge med innerspår bakom bilen i den högsta avdelningen av spårtrapporna i delningspropositionen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/11/251118.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens tävlingar.</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/2022/09/backoftheneck392022nim-617x412.jpeg" alt="" class="wp-image-349620"/><figcaption class="wp-element-caption">Åke Svanstedt-tränade Back of the Neck och Tim Tetrick vinner Maple Leaf Trot 2022. Foto New Image Media</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Avelshingsten <strong>Back of the Neck</strong> (e. Ready Cash-Big Barb), 1.08,7/$1.463.733, håller på att syndikeras. 48 av 120 ägarandelar bjuds ut till försäljning genom Blue Chip Farms i USA.</p>



<p class="wp-block-paragraph">Back of the Necks första avkommor har varit ute på auktion i år och på andra sidan Atlanten har ett sto och en hingst sålts för sexsiffriga belopp i dollar; <strong>French Pastry</strong> (u. Tart of My Heart) och <strong>Neck Beads</strong> (u. Pay For Soup) kostade 105.000 respektive 100.000 dollar. </p>



<p class="wp-block-paragraph">Två ettåriga hingstar har klubbats i Sverige för höga belopp. På Elitauktionen betalades 875.000 kronor för <strong>Wallet Tile</strong> (u. Billie Claire) och på Åby Yearling Sale såldes <strong>Orlando Journey</strong> (u. Fabulous Journey) för 650.000 kronor. </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/2023/05/frodehamre-617x333.jpg" alt="" class="wp-image-450191"/><figcaption class="wp-element-caption">Frode Hamre. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6När svenskfödde fyraåringen <strong>Get Going</strong> (e. Trixton) och Vidar Hop vann gårdagskvällens sista lopp på Sörlandet och tog karriärens första seger var förstapriset ljumma 16.000 kronor. Men det var en seger som betydde desto mer.<br>Tränaren Frode Hamre inkasserade nämligen triumf 3.000 i tränarkarriären!</p>



<p class="wp-block-paragraph">Drygt 13.000 starter har tagit Norges framgångsrikaste tränare att nå milstolpen och 61-åringen har inga planer på att dra ner på verksamheten som drivs på Ulleberg med 62 hästar på träningslistan.<br>– Jag vill inte trappa ned. Antingen fortsätter jag som idag eller så blir det ingenting. Jag skulle inte klara att hålla motivationen uppe med ett litet stall, sade Frode Hamre till Trav- og Galopp-Nytt efter att seger 2.999 tagits på hemmabanan Jarlsberg i lördags.</p>



<p class="wp-block-paragraph">Frode Hamre tog sin första tränarseger 2006 med <strong>Mystical News</strong> (e. Super News) i stoavdelningen av Jarlsberg Grand Prix, sedan han dessförinnan främst agerat catchdriver. Utvecklingen har varit stor och både 2022 och 2024 sprang stallets hästar in över 20 miljoner norska kronor, men redan 2013 satte han segerrekordet med 256 stallvinster. Totalt har det blivit över 230 miljoner kronor till stallet.<br>Som kusk har Frode Hamre 2.698 segrar.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Tvååriga finska stoet <strong>Miss White Gold</strong> (e. Maharajah) har gjort allt rätt under sin första säsong på tävlingsbanan. Fem starter har givit lika många segrar och den senaste togs i slutet av oktober i Hevosenomistajapokaali (€42.100) för Hannu Torvinen i Lahti.</p>



<p class="wp-block-paragraph">Hannu-Pekka Korpi tränar Miss White Gold, som förutom svensk pappa i <strong>Maharajah</strong> har en svensk mor i <strong>Giant Chocolate</strong> (e. Chocolatier).<br>På lördag i Jyväskylä väntar tvååringssäsongens största uppgift Breeders Crown – eller Kasvattajakruunu som är det finska namnet. Miss White Gold möter sex jämnåriga ston och har överlägsna meriter i sällskapet.</p>



<p class="wp-block-paragraph">En svenskfödd häst finns med i Riina Rekälä-tränade <strong>Viking Wania</strong> (e. Walner) i Breeders Crown för tvååriga hingstar och valacker.</p>



<p class="wp-block-paragraph"><strong>Startlista Breeders Crown (€55.000) – tvååriga ston</strong><br>2.140 meter autostart, Jyväskylä lördag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Windy Nimbus</strong> (e. Express Duo) – Jarmo Saarela</li>



<li><strong>Arctic Greetta</strong> (e. Calgary Games) – Janne Korpi</li>



<li><strong>Cortina Games</strong> (e. Calgary Games) – Santtu Raitala</li>



<li><strong>Ava di Alcee</strong> (e. Express Duo) – Ari Moilanen</li>



<li><strong>Springwind Sooti</strong> (e. Like di Poggio) – Kaarlo A Palojärvi</li>



<li><strong>Donna Madeleine</strong> (e. Maharajah) – Olli Koivunen</li>



<li><strong>Miss White Gold</strong> (e. Maharajah) – Hannu Torvinen</li>
</ol>



<p class="wp-block-paragraph"><strong>Startlista Breeders Crown (€44.000) – tvååriga h/v</strong><br>2.140 meter autostart, Jyväskylä lördag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Dewey Swamp</strong> (e. Green Manalishi) – Santtu Raitala</li>



<li><strong>Viking Wania</strong> (e. Walner) – Riina Rekilä</li>



<li><strong>The Enigma</strong> (e. Diamant Duo) – Ari Moilanen</li>



<li><strong>Reason to Rock</strong> (e. Express Duo) – Hannu-Pekka Korpi</li>



<li><strong>Club Nord Prince</strong> (e. Andover Hall) – Jarmo Saarela</li>



<li><strong>Seven of Diamonds</strong> (e. Seven And Seven) – Olli Koivunen</li>



<li><strong>Scudetto</strong> (e. Nad Al Sheba) – Esa Holopainen</li>



<li><strong>Bebeto Mania</strong> (e. Il Villaggio) – Jani Routsalainen</li>
</ol>
