
<p class="has-drop-cap">1 Hela 13 svenska rekord har slagits under 2025 och bäst är tvååriga <strong>Cruiser </strong>med dubbla rekord. Först raderade Johan Untersteiners sto ut <strong>Denim Bokos </strong>1.12,9a/1.640 meter från Svensk Uppfödningslöpning i november 2011 till 1.12,7a och sedan krossade Calgary Games-dottern sitt eget rekord och noterade 1.12,1a.</p>



<p>Ett annat långlivat rekord som slogs var från 2015. <strong>Spoil Me</strong> vann Svenskt Trav-Oaks på 1.11,5a/2.140 meter och den tiden skickades till historieböckerna av <strong>Moder Terersa Sisu</strong> (e. Walner) när hon vann samma löpning på Solvalla.</p>



<h2 class="wp-block-heading">Här är listan över svenska rekordhållare 2025:</h2>



<p><strong>Tvååriga ston:</strong></p>



<ul class="wp-block-list">
<li><strong>Cruiser </strong>(e. Calgary Games-Mary’s Out Cruisin) – Johan Untersteiner<br><em>– 1.12,7a/1640 meter, Jägersro 7 september.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Cruiser</strong> (e. Calgary Games-Mary’s Out Cruisin) – Johan Untersteiner<br><em>– 1.12,1a/1640 meter, Jägersro 1 oktober.</em></li>
</ul>



<p><strong>Treåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>Ottens Meteor (</strong>v e. Maharajah-Uptown B. Girl) – Björn Goop<br><em>– 1.13,1/2.180 meter, Årjäng 5 oktober.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Wise Guy </strong>(e. Face Time Bourbon-All Wise As) – Per Nordström<br><em>– 1.11,0a/2.140 meter, Solvalla 25 maj.</em></li>
</ul>



<p><strong>Treåriga ston:</strong></p>



<ul class="wp-block-list">
<li><strong>Henessi Joyride</strong> (e. Don Fanucci Zet-Alegria Am) – Magnus A Djuse<br><em>– 1.12,4/1.640 meter, Axevalla 19 juli. <strong>Tränare: </strong>Mattias Djuse.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Moder Teresa Sisu</strong> (e. Walner-Dixi Sisu) – Magnus A Djuse<br><em>– 1.11,4a/2.140 meter, Solvalla 11 oktober. <strong>Tränare: </strong>Timo Nurmos.</em></li>
</ul>



<p><strong>Fyraåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>Double Nature </strong>(v e. Fourth Dimension-Fanny Sisu) – Carl Johan Jepson<br><em>– 1.11,6/1.640 meter, Eskilstuna 5 juni. <strong>Tränare:</strong> Sofia Aronsson Hofstedt.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Bullet the Bluesky</strong> (e. Readly Express-Blend of Gold) – Daniel Wäjersten<br><em>– 1.10,3a/2.140 meter, Bergsåker 24 juli.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Shogun R.R.</strong> (v e. Readly Express-Vendome) – Daniel Wäjersten<br><em>– 1.13,3/3.140 meter, Bergsåker 29 augusti.</em></li>
</ul>



<p><strong>Femåriga äldre hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>Mellby Jinx </strong>(v e. Ready Cash-Heaven’s Door) – Mats E Djuse<br><em>– 1.08,8a/1.609 meter, 25 maj Solvalla. <strong>Tränare:</strong> Timo Nurmos.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Micke Sting</strong> (e. Readly Express-Whoopsiedaisy Zet) – Claes Sjöström<br><em>– 1.12,7a/2.640 meter, 14 oktober Eskilstuna.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Francesco Zet</strong> (e. Father Patrick-Shaqline) – Örjan Kihlström<br><em>– 1.11,1a/2.640 meter, 27 september Åby. <strong>Tränare: </strong>Daniel Redén.</em></li>
</ul>



<ul class="wp-block-list">
<li><strong>Immortal Doc</strong> (e. Brillantissime-Nikita Broline – Björn Goop<br><em>– 1.12,8a/3.140 meter, 16 augusti Åby. <strong>Tränare:</strong> Fredrik Wallin.</em></li>
</ul>



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



<p class="has-drop-cap">2 <strong>Åby</strong> har sedan i somras under namnet super boost höjt förstapriset i två lopp från 40.000 till 75.000 kronor på sina V64-dagar under veckorna. Ikväll (första start 18.20) är det dags för årets två sista lopp i kategorin och målsättningen att höja klassen på vardagslopp har verkligen lyckats i den ena avdelningen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/robertberghsulky-617x333.jpg" alt="" class="wp-image-732831"/><figcaption class="wp-element-caption">Robert Bergh. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Ett koppel hästar av silverdivisionsklass möts nämligen med Robert Berghs förvärv <strong>Swish the Cash</strong> (e. Ready Cash) i huvudrollen. Denne kom till Åbytränaren i slutet av sommaren och har hunnit med två starter – båda har slutat med seger!</p>



<p>Nu inleder hästen från tredjespår bakom bilen och har på insidan André Eklundhs kapable fyraåring<strong> Limoncello Boko</strong> (e. Muscle Mass) som främste utmanare.</p>



<p>Efter kvällens tävlingar återstår två lunchdagar av tävlingssäsongen på Åby och Johan Untersteiner och Carl Johan Jepson går en stenhård kamp om championatet, där Johan just nu leder med 57-55.</p>



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



<p class="has-drop-cap">3 Intresset för att tävla efter vinterns – nåja – och barfotaförbudets intåg har inte svalnat. Till <strong>Örebros</strong> lunchtävlingar (första start 12.20) anmäldes 132 hästar till delningspropositionen för höstar med högst 1.500 startpoäng.</p>



<p>96 av dem får chansen att tävla sedan loppet delats i åtta istället för sex som det var tänkt enligt ursprungspropositionen.</p>



<p>Björn Goop reser från Kil med tre hästar, födda i tre olika länder. Svenskfödde <strong>Clog</strong> (e. Greenshoe) testas i tvååringsloppet, medan spanske <strong>Likearollingstone</strong> (e. Love You) och tyske <strong>Julius Cortina</strong> (e. Love You) kommer ut i varsin spårtrappa i delningspositionen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/12/251211.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/12/251211.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 2017 såg Margareta Wallenius-Klebergs, Solvallas och Svensk Travsports svenska satsning Margaretas Tidiga Unghästserie dagens ljus. 16 lopp med 300.000 kronor i förstapris i varje och en total prispott på 9,6 miljoner kronor var upplägget.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/12/mwk.jpg" alt="" class="wp-image-802197"/></figure>



<p>Margareta-serien skrevs först som ett femårsavtal. Det förlängdes under den femte säsongen och gäller nu till och med 2026. Totalt kommer det att ha tävlats om närmare 100 miljoner kronor i serien, som är förbehållen svenskfödda travare.</p>



<p>Loppen har flyttats om lite i 2026 års schema. Tidigare inleddes det med öppen klass för treåringarna i februari, men nästa år är första loppet stängt vid 200.000 kronor. Istället blir det ett lopp för alla hästar vid omgången i slutet av mars.</p>



<h2 class="wp-block-heading">Så körs Margaretas Tidiga Unghästserie 2026:</h2>



<p>(En avdelning vardera för svenskfödda ston och hingstar/valacker):</p>



<p><strong>7 februari:</strong></p>



<ul class="wp-block-list">
<li>Treåringar – högst 200.000 kr</li>



<li>Fyraåringar – högst 250.000 kr</li>
</ul>



<p><strong>28 mars:</strong></p>



<ul class="wp-block-list">
<li>Treåringar – för alla hästar</li>



<li>Fyraåringar – för alla hästar</li>
</ul>



<p><strong>15 maj:</strong></p>



<ul class="wp-block-list">
<li>Treåringar – högst 350.000 kr</li>



<li>Fyraåringar – för alla hästar</li>
</ul>



<p><strong>28 juni:</strong></p>



<ul class="wp-block-list">
<li>Treåringar – för alla hästar</li>



<li>Fyraåringar – högst 450.000 kr</li>
</ul>



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



<p class="has-drop-cap">5 Årets högst doterade tvååringslopp för hingstar på fransk mark hålls på lördag på Vincennes och tolv hästar finns med i Prix Emmanuel Margouty (€120.000) över distansen 2.700 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/skarmavbild20251129kl.14.09.46-617x329.jpg" alt="" class="wp-image-798594"/><figcaption class="wp-element-caption">Nob Hill vinner för Mathieu Mottier.</figcaption></figure>



<p>Mathieu Mottier plockar ut i tre starter obesegrade <strong>Nob Hill</strong> (e. Gu d’Heripre) och som i senaste starten tog hem Prix des Dahlias (€43.000) på 1.14,9/2.700 meter.</p>



<p><strong>Prix Emmanuel Margouty</strong> (€120.000)<br>Tvååriga hingstar.<br><em>2.700 meter.</em></p>



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



<ol class="wp-block-list">
<li><strong>Namour Dab</strong> (e. Un Amour d’Haufor) – Damien Bonne</li>



<li><strong>Nuevo Cash</strong> (e. Ready Cash) – Théo Duvaldestin</li>



<li><strong>Nitro Dairpet</strong> (e. Inou Danica) – Alexandre Abrivard</li>



<li><strong>Never Forget</strong> (e. Hohneck) – Alexandre de Jesus</li>



<li><strong>New Success</strong> (e. Boccador de Simm) – Yoann Lebourgeois</li>



<li><strong>Nob Hill </strong>(e. Gu d’Heripre) – Mathieu Mottier</li>



<li><strong>Nelson Emge</strong> (e. Hohneck) – Benjamin Rochard</li>



<li><strong>Nat King Cole</strong> (e. Ready Cash) – David Thomain</li>



<li><strong>Nuage de Beaucamps</strong> (e. Galius) – Patrick Desprez</li>



<li><strong>Nobel Venesi </strong>(e. Hohneck) – Paul-Philippe Ploquin</li>



<li><strong>Nectar d’Avignere </strong>(e. Ouragan de Celland) – Eric Raffin</li>



<li><strong>Nelson de Busset </strong>(e. Gotland) – Pierre-Yves Verva</li>
</ol>



<p><strong>Fotnot: </strong>de tvååriga stonas semi-classique-löpning Prix Une de Mai (€120.000) hålls på Vincennes på söndag och den definitiva startlistan blir klar under förmiddagen.</p>



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



<p class="has-drop-cap">6 Tysk travsport har länge haft det tungt ekonomiskt och till helgen är det inställda tävlingar både i Straubing och Hamburg.<br>Anledningen? För få anmälda hästar…</p>



<p>– Även efter att anmälningsfristen förlängts är antalet anmälda hästar långtifrån tillräckligt för att genomföra en tävlingsdag. Vi beklagar detta djupt, men tyvärr är vi tvungna att ställa in tävlingsdagen, skriver Bahrenfeld-banan i Hamburg på sin hemsida.</p>



<p>Därremot blir det tävlingar i Mönchengladbach på söndag. Nio lopp ska avverkas och 65 hästar har definitivanmälts, vilket betyder 7,2 hästar i snitt per lopp.</p>



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



<p class="has-drop-cap">7 Västerbo Stuteri har investerat i en ny avelshingst och förvärvat <strong>Cash Okay</strong> (e. Ready Cash-Tresokay), 1.11,0ak/3.087.355 kr, från den tidigare ägaren och uppfödaren Kjell Otto Molander i Norge.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/12/cashokay2112061251-617x420.jpg" alt="" class="wp-image-802231"/><figcaption class="wp-element-caption">Cash Okay. Bild: Västerbo Stuteri</figcaption></figure>



<p>Norskfödde Cash Okay vann 13 lopp under sin karriär och däribland Holm Holmsens Minneslopp 2016. Samma år slutade han tvåa i Norskt Derby och året innan trea i Europeiskt Treåringsmästerskap.</p>



<p>Cash Okay har 34 svenskfödda avkommor och de äldsta är två år gamla. En av dem – <strong>Kurt Med K</strong>. – har varit ute på tävlingsbanan, tagit rekordet 1.17,7k och tjänat 31.800 kr.</p>



<p>– Över hälften har gått premielopp, berättar Michael Demmers.</p>
