
<p class="has-drop-cap wp-block-paragraph">1I eftermiddag väntar Sveriges största tvååringslopp, Svensk Uppfödningslöpning med 1,2 miljoner kronor till vinnaren, på Jägersro (första start 15.20).<br>Det kunde ha varit dags att kora den 100:e vinnaren då första upplagan avgjordes redan 1926, men det jubiléet får vänta – loppet ställdes in tre gånger på 1960-1970-talet.</p>



<p class="wp-block-paragraph">Framgångsrikaste tränare i Svensk Uppfödningslöpnings historia är Sören Nordin med nio vinnare, följd av Lutfi Kolgjini med sju segrar och Svante Båth med fem vinster. Skulle Per Nordström vinna i år – <strong>Victorious Tile</strong> är hoppet sedan stallets andra häst <strong>MissMoneypenny S.F.</strong> tvingats strykas – kommer han upp på fyra triumfer.</p>



<p class="wp-block-paragraph">Av tränarna bakom årets finalister har förutom Nordström även holländaren Erwin Bot vunnit tidigare. Han är mannen bakom fjolårets etta <strong>Pele Boko</strong> (e. Readly Express) och ställer årets hopp till <strong>Revanche Boko</strong> (e. Face Time Bourbon). Örjan Kihlström kör, precis som förra året bakom Pele Boko.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/johnbootsmanreaganboko-617x333.jpg" alt="" class="wp-image-795201"/><figcaption class="wp-element-caption">John Bootsman har flest uppfödarsegrar i Svensk Uppfödningslöpning och kan ta en till med Reagan Boko. Foto Mia Törnberg/Sulkysport &#038; Mikael Rosenquist/Miro Media</figcaption></figure>



<p class="wp-block-paragraph"><strong>Här är Sulkysports långläsning inför Svensk Uppfödningslöpning:</strong></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/boko-mot-femte-segern/" target="_blank" rel="noreferrer noopener">Det snackas om Svensk Uppfödningslöpning: Smått &#038; gott!</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/den-blyge-hollandaren/" target="_blank" rel="noreferrer noopener">Robin Bakker: ”Den blyge holländaren” kör favoriten</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/klockan-avgjorde-premiaren-2/" target="_blank" rel="noreferrer noopener">Historik: ”Klockan avgjorde vem som skulle koras till vinnare”</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Svenska rekorden för tvååringar kan vara bra att veta inför dagens final. Snabbaste svenskfödde hingst/valack är Per Nordström-tränade <strong>Eyeofthetiger</strong> (e. Django Riff) som travade 1.12,0a/1.640 meter i försöket till Svensk Uppfödningslöpning förra året.</p>



<p class="wp-block-paragraph">Stonas svenska rekord är purfärskt – den 1 oktober i år vann Johan Untersteiner-tränade <strong>Cruiser</strong> (e. Calgary Games) finalen i Breeders Course för tvååriga ston på 1.12,1a/1.640 meter med Johan i vagnen.</p>



<p class="wp-block-paragraph">Denne har kvalat in två hästar till årets final, men ingen av dem heter Cruiser. rekordhållarinnan är skadad och laddas för nästa säsong. Största hoppet är istället <strong>Royal Steel</strong> (e. Muscle Hill), som vann sitt försök på 1.13,1a.<br>– Royal Steel är det väldigt uppåt på. Hon blir bättre och bättre varje gång och har spännande läge. Hon öppnade bra en bit ut i banan i försöket och jag tror att det finns mer från början. Nu blir det rycktussar också, så pass upp, sade Johan Untersteiner till V65 Direkt.</p>



<p class="wp-block-paragraph">Från 1.600 meter till 2.140 meter har distansen varierat i Svensk Uppfödningslöpning sedan premiäråret 1926. <strong>Fascination</strong> (e. Super Arnie) vann senaste – sista? – året över medeldistans 2011 på snabbaste tiden över distansen, 1.15,3a/2.140 meter. Snabbaste sprintern är 2023 års vinnare <strong>L’Amourpourplanca</strong> (e. Face Time Bourbon) på 1.12,4a/1.640 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/lamourpourblancamalgang-617x411.jpg" alt="" class="wp-image-527190"/><figcaption class="wp-element-caption">L&#8217;Amourpourblanca och Rick Ebbinge vann Svensk Uppfödningslöpning på tangerat europarekord 2023. Foto: Mikael Rosenquist/MiRo Media</figcaption></figure>



<h2 class="wp-block-heading">Snabbaste vinnarna av Svensk Uppfödningslöpning</h2>



<p class="wp-block-paragraph"><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2023 <strong>L’Amourpourplanca</strong> (e. Face Time Bourbon) – Rick Ebbinge – 1.12,4a</li>



<li>2016 <strong>Coin Perdu</strong> (e. S.J.’s Caviar) – Erik Adielsson (Svante Båth) – 1.12,7a</li>



<li>2012 <strong>Denim Boko</strong> (e. Chocolatier) – Per Nordström – 1.12,9a</li>



<li>2017 <strong>Global Welcome</strong> (e. S.J.’s Caviar) – Erik Adielsson (Svante Båth) – 1.13,1a</li>



<li>2019 <strong>Revelation</strong> (e. Ready Express) – Per Nordström – 1.13,4a</li>



<li>2022 <strong>Fiftyfour</strong> (e. Fourth Dimension) – Ken Ecce (Tomas Malmqvist) – 1.13,4a</li>



<li>2013 <strong>Onceforall Face</strong> (e. Viking Kronos) – Lutfi Kolgjini – 1.13,7a</li>



<li>2018* <strong>Belker</strong> (e. Scarlet Knight) – Torbjörn Jansson (Sten O Jansson) – 1.13,7a</li>



<li>2018* <strong>Bythebook</strong> (e. Googoo Gaagaa) – Örjan Kihlström (Svante Båth) – 1.13,7a</li>



<li>2024 <strong>Pele Boko</strong> (e. Readly Express) – Örjan Kihlström (Erwin Bot) – 1.13,7a</li>
</ul>



<p class="wp-block-paragraph">Samtliga ovanstående tider är noterade över 1.640 meter med autostart.<br><em>* Belker och Bythebook löpte dött lopp om segern.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">3Svensk Uppfödningslöpning är höjdpunkten på Jägersros (första start 15.10) V85-omgång, där det även blir en hyllning av en av banans bästa äldre hästar i historien. Jägersrotränaren Lars Gustafsson var mannen som formade jänkaren <strong>Meadow Prophet</strong> (e. Speedy Somolli), 1.11,9ak/7.030.235 kr, till en topphäst.<br>Han var tvåa i Elitloppet bakom kanadensiske Billyjojimbob 1992 efter att på våren vunnit Silverhästen på Solvalla. Året efter slutade Meadow Prophet fyra i Elitloppet innan säsongen avslutades med seger i Müllers på hemmaplan, Gran Premio delle Nazione i Milano och Gran Premio Gaetano Turilli i Rom.<br>På väg norrut från Rom fattade hästtransporten med Meadow Prophet, <strong>First Sid</strong> (Björn Linder) och <strong>Park Avenue Kathy</strong> (Göran E Johansson) eld och den svensktränade trion dog. Tre framgångsrika travliv dog. Totalt gjorde Meadow Prophet 61 starter (25–14–11).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/afairdayelitlopp1-617x333.jpg" alt="" class="wp-image-628955"/><figcaption class="wp-element-caption">A Fair Day. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Kalmarstjärnan <strong>A Fair Day</strong> (e. Maharajah) är en av hästarna som dyker upp i Meadow Prophets Minne. Förra året slutade han knappt slagen som tvåa bakom ledande <strong>B.A.Superhero</strong> (e. Muscle Hill). Blir det spets och seger den här gången trots åttondespår bakom bilen?<br>– Från spår åtta kan man inte vara lika bestämd som från spår ett om vad man ska göra. Det är lättare att vinna om man kommer till ledningen, men jag får se hur det känns i värmning och när jag kör upp bakom bilen. Jag kommer inte att bestämma mig före det. Enligt träningsrapporterna är han ännu piggar efter senaste starten, sade Oscar Ginman till V65 Direkt.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Tvååringarnas största lopp och Sveriges äldsta klassiker. Det spetsas med tredje jackpotomgången av fem möjliga lördagar på V85-spelet. 23,5 miljoner extra har lagts in i sjurättspotten sedan utdelningen uteblev på både sexor och femmor förra lördagen. </p>



<p class="wp-block-paragraph">Sulkysports expertpanel med några av landets vassaste tippare har förstås synat omgången noga och bjuder på sin bästa spik och ett roligt skrällbud i omgången på Jägersro.</p>



<p class="wp-block-paragraph">Bland skrällarna finns både en tvåprocentare och en fyraprocentare med möjligheter!</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-jackpot-j-22-nov/" target="_blank" rel="noreferrer noopener">––> Kolla in alla drag för experterna här!</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/11/22v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens V85-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/2024/08/ay2x2874kopier-617x411.jpg" alt="" class="wp-image-625579"/><figcaption class="wp-element-caption">Icebreaker vid segern i Danskt Derby ifjol för Magnus A Djuse. Foto: Kjeld Mikkelsen/K M Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Efter att ha besegrat Epic Kronos i Triton Sunds lopp på Solvalla i början av november vände Mattias Djuse blickarna mot Frankrike och Vincennes med sin femårige danske stjärna <strong>Icebreaker</strong> (e. Chocolatier). I eftermiddag är det dags i lejonets kula.</p>



<p class="wp-block-paragraph">Med Eric Raffin i vagnen startar Icebreaker i fyra- och femåringsloppet Prix de Chenonceaux (€80.000) .ver 2.700 meter med 36.000 euro till vinnaren. Fjolårets danske Derbyvinnare har haft en fin femåringssäsong med andraplatsen i Margareta Wallenius-Klebergs Pokal på Solvalla i augusti som tyngsta merit. <br>Icebreaker står bra inne på pengarna i loppet och möter bland annat Nicholas Bazire-tränade, svenskfödde <strong>Killiam Fromentro</strong> (e. Villiam) och <strong>Karambar</strong> (e. Dollar Macker) med tre raka segrar.</p>



<p class="wp-block-paragraph">Ytterligare tre svenskfödda häst tävlar på Vincennes idag. Sjuårige <strong>Invisible Sun</strong> (e. Ready Cash), som vann klass I-försök i Per Linderoths regi för två år sedan, återfinns numera hos Erik Bondo och debuten i dennes regi sker alltså under sadel i Prix de la Clayette (€49.000) med 22.050 euro till vinnaren.<br>Han ställs mot Conrad Lugauer-tränade <strong>Leroy Boko</strong> (e. Trixton) och Christophe Galliers <strong>Robthebank</strong> (e. The Bank), som tidigare tränades av Fredrik B Larsson och vann lopp på fransk mark i slutet av augusti. Båda hästarna är fortsatt svenskägda.</p>



<p class="wp-block-paragraph"><a href="https://pro.letrot.com/siteinstit/A4/20251122_VINCENNES_TROT_COULEUR.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar idag.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Den svenska travkvällen avslutas på Axevalla (start 18.35) med treåringsloppet Lassagårdspokalen som höjdare. Loppet är öppet för enbart Axevallatränade hästar och har samlat nio deltagare.</p>



<p class="wp-block-paragraph">Ingen av dem har passerat en kvarts miljon kronor hittills, men det finns flera som testat på hetluften på allvar. <strong>Dats Bella</strong> och <strong>Budets Hildur</strong> – båda med Power som pappa – testades i Oakskval utan framgång, men möttes förra veckan på Axevalla med Budets Hildur som vinnare före Dats Bella på låga tider. Fast desto snabbare har Budets Hildurs stallkamrat <strong>Caribbian Lemon</strong> (e. Hayden Hanover) travat med 1.11,7ak i korta E3-finalen i somras.</p>



<p class="wp-block-paragraph">Dagen inleds i Bollnäs (start 11.10) med breddlopp, där unge Fredrik Plassen kör sju lopp. Det kommer han inte kunna göra nästa år. Hans rekordsäsong 2025 plockar bort Gävlelärlingen från breddlopp efter 49 segrar på 365 starter under året.<br>Idag har han en mangrann uppgift när han sitter upp bakom treåriga stoet <strong>Nordlilja</strong> (e. Tekno Odin) för första gången. Jan-Olov Persson tränar hästen som galopperat i tio av tolv starter – men vunnit de två gånger hon travat felfritt. Dags för tredje vinsten nu?</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/11/251122.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens 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/2023/06/almraujoupp-617x333.jpg" alt="" class="wp-image-463344"/><figcaption class="wp-element-caption">Jon A Högstad tillsammans med sin ultratalang Alm Rau Jo. Foto Hesteguiden.com</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Ett av de allra största ämnen som skådats på tävlingsbanan, men en karriär som tog ut alldeles för snabbt efter sjukdom. Ikväll på Orkla Arena utanför Trondheim hedras ultratalangen <strong>Alm Rau Jo</strong> (e. Rigel Jo) med ett eget treåringslopp.</p>



<p class="wp-block-paragraph">Hästen, som tränades av Jon A Högstad och kördes av Jomar Blekkan, debuterade med vinst på 1.30,4 som tvååring (!) och vässade tiden till 1.29,6 i sin tredje tvååringsstart. På den tiden kördes ett fåtal tvååringslopp för kallblod och Alm Rau Jos tid står sig förstås fortfarande som världsrekord.<br>Som treåring vann han Kriteriet både i Sverige och Norge, men åkte på karriärens enda förlust i Biris Uppfödningslopp en dag då travet inte alls stämde och hästen dessutom blev rapporterad för orent trav.<br>Det var enda snedstegen på banan, men efter 24 segrar och ett andrapris på 25 starter fick karriären ett tragiskt slut. Alm Rau Jo visade tecken på kolik efter ett träningspass i mars som fyraåring, fick behandling men blev inte bättre. Två operationer gjordes för att rädda hästen, men utan framgång. Alm Rau Jo dog av tarmvred när hans karriär och liv bara var i sin linda. 2.080.962 norska kronor hann han springa in och som treåring travade han rekordet 1.26,2/1.640 meter med voltstart.</p>



<p class="wp-block-paragraph">Nio treåriga kallblod tävlar om förstapriset på 50.000 kronor på Orkla. Bergsåkeramatören Ola Åsebö åker ”hem” till Tröndelag med två hästar. <strong>Casper A.Y. </strong>(e. Smedheim Solan) startar i just Alm Rau Jos lopp, medan 2023 års vinnare i korta E3 för ston, <strong>Coral Coger</strong> (e. Ken Warkentin), kommer ut i högsta klassen.</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/varig-orkla-arena/startlist/2025-11-22" target="_blank" rel="noreferrer noopener">Här är startlistorna till Orklas tävlingar.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Ryker svenska rekordet?
Stallets stjärna skadad – då försvarar snabbaste försöksvinnaren Untersteiners färger. Rekorden att slå. A Fair Day jagar revansch i Meadow Prophets lopp. Icebreaker i debut på Vincennes. Tidernas största talang (?) hedras med minneslopp.
Detta och mer i ”sju nyheter vid sju”.
Detta och mer i ”sju nyheter vid sju”.
