
<p class="has-drop-cap">1Unionskampen är ett av de allra största loppen för kallblodseliten årligen – och årets upplaga på Färjestad på lördag håller allra högsta klass med både Sveriges och Norges främsta kallblod för dagen i startlistan. De nio deltagarna i Unionskampen har dessutom tuffast tänkbara löpningsrekord att försöka utmana.</p>



<p>I Unionskampen har det nämligen slagits världsrekord! 2016 svarade <strong>Tekno Odin</strong> (e. Moe Odin) för en närmast osannolik prestation när han efter tuff resa landade på 1.19,1a/2.140 meter tillsammans med Öystein Tjomsland. Detta efter att ha inlett första varvet på 1.17,4 för att ta täten av Solör Stegg.</p>



<p>Sju gånger har det krävts en tid under 1.21 för att vinna storloppet och räkna med att det kommer att gå undan även i årets upplaga. Fjolårsvinnaren och världsrekordhållaren över sprinterdistans, <strong>Brenne Borken</strong> (e. Bork Odin), står dock kvar i stallet.<br>– Brenne Borken har opererats i hals och knän, han har haft en lugn sommar och bara slappnat av. Nu har vi försiktigt startat uppträningen. Han bestämmer själv när han kan vara tillbaka, men han har varit ojämn i år och vi körde med halskamera i träning hemma och såg en avvikelse. Det var grunden till operationen, som gick bra och alla efterkontroller har varit bra, sade Öystein Tjomsland till ATG Live.</p>



<p>Hans kort i Unionskampen går inte av för hackor, nästan niofaldige miljonären <strong>Tangen Bork</strong> (e. Bork Odin), som själv kommit tillbaka i sommar efter operation förra hösten. Efter två raka segrar har dock Tangen Bork galopperat tre starter i rad inför detta.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/12/teknoodinmg1-617x333.jpg" alt="" class="wp-image-57423"/><figcaption class="wp-element-caption">Tekno Odin och Öystein Tjomsland vid seger i Unionskampen på Färjestad. Foto Urban Kihlman/ALN</figcaption></figure>



<p><strong>Snabbaste vinnarna av Unionskampen</strong><br><em>År – segertid: vinnare (far) – Körsven (tränare)</em></p>



<ul class="wp-block-list">
<li>2016 – 1.19,1a: <strong>Tekno Odin</strong> (e. Moe Odin) – Öystein Tjomsland</li>



<li>2019 – 1.20,3a: <strong>Odd Herakles</strong> (e. Moe Odin) Tom Erik Solberg (Lars O Romtveit)</li>



<li>2017 – 1.20,4a: <strong>Odin Tabac</strong> (e. Moe Odin) – Oskar J Andersson (Jörgen Westholm)</li>



<li>2023 – 1.20,4a: <strong>Stumne Fyr</strong> (e. Joker Elden) – Ole Johan Östre (Merete Viksås)</li>



<li>2025 – 1.20,6a: <strong>Brenne Borken</strong> (e. Bork Odin) – Öystein Tjomsland</li>



<li>2015 – 1.20,9a: <strong>Lome Brage</strong> (e. H.G.Balder) – Per Oleg Midtfjeld (Bengt Erik Persson)</li>



<li>2020 – 1.20,9a: <strong>Odd Herakles</strong> (e. Moe Odin) Tom Erik Solberg (Odd Paulsen)</li>
</ul>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/09/19v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens V85-tävlingar på Färjestad.</a></p>



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



<p class="has-drop-cap">2Ensam kvällsbana i Sverige är Bergsåker (första start 18.20) och en miljon kronor extra ligger i sexrättspotten i form av jackpotpengar från gårdagen på Solänget, där ingen fixade alla sex rätt.</p>



<p>Det är några extra spännande ungdomar som dyker upp i startlistorna på Bergsåker.<br>Italienskfödde <strong>Ihaveadream Gar</strong> (e. Greenshoe-Seibella Park) msatte punkt för en fläckfri tvååringssäsong i hemlandet när han i juletider tog hem grupp III-loppet Criterium Sud (€30.030) i Taranto på 1.13,6a/1.600 meter från ledningen. Det var femte segern på lika många försök.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/12/skarmavbild20251227kl.09.15.51-617x377.jpg" alt="" class="wp-image-806496"/><figcaption class="wp-element-caption">Invändige Ihaveadream Gar håller undan för Ideal Top i december ifjol.</figcaption></figure>



<p>I år har han inte firat samma framgångar och efter att ha gått segerlös från fem starter bytte han både tränare och hemland när hästen i juli anlände till Daniel Wäjersten.<br>I ett treåringslopp mot bland annat tre stallkamrater kommer ett första kvitto på var den italienske travaren står.</p>



<p>Fortsatt obesegrad – efter tre starter – är däremot Daniel Redéns ämne <strong>Miss Brighton</strong> (e. Calgary Games), som rekordsänkte till 1.14,4am vid senaste triumfen. Nu väntar ett möte med äldre hästar i väntan på större uppgifter inom kort.<br>– Miss Brighton var tillbaka efter uppehåll senast och gjorde det bra direkt även om vi kanske hade lite tur att den utvändige galopperade i sista sväng. Det stod och vägde och hon ville inte ge sig, så man vet aldrig hur det hade gått. Hon har bra inställning till tävlandet och bör vara ytterligare lite bättre den här gången med loppet i kroppen och hon fick ett bra läge. Hon behöver få ett lopp till innan Oaks-kval och det blir skor och vanlig vagn, säger Daniel Redén på sin hemsida <a href="http://reddis.se" target="_blank" rel="noreferrer noopener">reddis.se</a>.</p>



<p>Ett treåringslopp för kallblodiga ston har samlat sex ston – och fyra av dem var finalister i Kriteriestoet på Dannero i början av augusti. <strong>L.Q.Tira</strong> (e. Art Kjarvald) lyckades bäst med fjärdeplatsen, medan <strong>Feseth Astrid</strong> (e. Gomnes Hans T.), <strong>Prussiluskan</strong> (e. Monster Monsun) och <strong>Önnes Engla</strong> (e. Ängsborken) gick lottlösa från finalen. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/susannehosterling-617x333.jpg" alt="" class="wp-image-824965"/><figcaption class="wp-element-caption">Susanne H Osterling. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3Startfältet till Dam-SM i Eskilstuna den 4 oktober med 150.000 kronor i förstapris tar form. Ikväll på Bergsåker körs det näst sista försöket för kuskar med licens på Bergsåker, Dannero, Solänget och Östersund. </p>



<p>Bland de tolv kvinnorna finns Solängetproffset Susanne H Osterling, som har två titlar i Dam-SM på meritlistan. Hon segrade 2014 med <strong>Saxo Holmsminde</strong> (e. Dream Vacation) och 2019 med <strong>Caligula</strong> (e. Coktail Jet). I år heter hennes hopp <strong>Com Isidor</strong> (e. Villiam).</p>



<p>Sista uttagningsloppet körs i Skellefteå på fredag med kuskar hemmahörande i Boden, Skellefteå och Umeå. De sex försöksvinnarna lottas på spår 1-6, medan tvåorna lottas på 7-12.</p>



<p><strong>Inkvalade till Dam-SM 2026:</strong><br><em>Häst – Kusk, hemmabana</em></p>



<p><strong>Vinnare: </strong></p>



<ul class="wp-block-list">
<li>Listas Champagne – Sophia Olsson Jacobsen, Åby</li>



<li>Excellent Diamon – Ailin Berg-Almaas, Axevalla</li>



<li>Farlow Selva – Rebecca Dahlén, Solvalla</li>



<li>Any Given Sunday – Hanna Forslin, Hagmyren</li>
</ul>



<p><strong>Tvåor: </strong></p>



<ul class="wp-block-list">
<li>Diamant Sensation – Sofie Ericsson, Halmstad</li>



<li>Sommarflirten – Julia Nilsson, Färjestad</li>



<li>Mister Aloha – Johanna Lind, Mantorp</li>



<li>Can’t Be Rules – Felicia Molin, Gävle</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/2026/04/jennifersisumadm260415adamstromstalltz-617x400.jpg" alt="" class="wp-image-838836"/><figcaption class="wp-element-caption">Jennifer Sisu rekordsänkte med sex tiondelar över medeldistans efter ha vunnit på svenskt rekord, 1.10,5a, på Solvalla i april. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">4Det är till sju åttondelar fyllda fält på dagens lunchbana Eskilstuna (första start 12.20) och till delningspropositionen anmäldes hela 92 hästar. 72 av dessa gör upp i sex spårtrappor med 35.000 kronor i förstapris.</p>



<p>Snabbloppet, också en spårtrappa, avgörs däremot med endast sex hästar bakom bilen över sprinterdistans. Timo Nurmos-tränade <strong>Jennifer Sisu</strong> (e. Peropulsion) är rikast i fältet med nästan fem miljoner kronor på kontot. Merparten av dessa – 3,1 miljoner – kom under fyraåringssäsongen 2023 då hon var lite av den eviga tvåan med silverpengar i Stochampionatet, Derbystoet och Stosprintern!</p>



<p>Efter att ha vunnit Karl-Erik Benders Minneslopp på Axevalla under årets Stochampionatshelg spändes bågen mot Sto-EM för en knapp månad sedan, men där fick hon strykas på grund av sårskada. Nu är hon tillbaka.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/09/260915.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens tävlingar.</a></p>



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



<p class="has-drop-cap">5Hösten är auktionernas tid och Arqana Trot i Deauville bjuder på en mixedauktion i eftermiddag – första utrop klockan 13.30 – och katalogen innehåller 179 hästar, varav drygt 100 hästar är i träning medan resten av utbudet består av bland annat ettåringar, föl och ston för avel.<br>Flera etablerade uppfödare säljer ut tvåsiffrigt; Haras des Quatre Vents, Ecurie du Haras d’Érable, SCEA des Bissons, Ecurie Thierry Duvaldestin och Ecurie du Damier.</p>



<p>Två av hästarna som bjuds ut är <strong>Moneytime Ducampus</strong> (e. Face Time Bourbon-Elisa de Vandel), 1.13,9l*/€44.065, och <strong>Neptuna</strong> (e. Fifty Kalouma-I Love Anna), 1.15,3l*/€31.680, som båda vunnit på Vincennes i år. </p>



<p>Även två svenskfödda travare finns med och däribland treåriga <strong>Mazeppa du Campus</strong> (e. Winston Sisa-Fanny Chenal), som kvalat på 1.21,4a/1.750 meter i Belgien. Stoet är halvsyster med <strong>L’Amourpourblanca</strong> (e. Face Time Bourbon), 1.11,3ak/2.446.552 kr, och vinnare av Svensk Uppfödningslöpning. <br>Vidare säljs åttaåriga stoet <strong>Italy Mearas</strong> (e. Muscle Hill), 1.12,3ak*/535.800 kr, vars mor heter <strong>Pleasure Kronos</strong> (e. Varenne), 1.11,6am/2.623.812 kr. </p>



<p><a href="https://www.arqana-trot.com/catalogue/vente-mixte-de-septembre-2026/237" target="_blank" rel="noreferrer noopener">Här hittar du hästarna som säljs i Deauville.</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/2023/03/prixalencon3-617x424.jpg" alt="" class="wp-image-420685"/><figcaption class="wp-element-caption">Self Explosive. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap">6Under nästan tre års tid tävlade Lena och Nils Elfvings valack <strong>Self Explosive</strong> (e. Explosive Matter), 1.10,0am/4.150.207 kr, oavbrutet på fransk mark med stor framgång. Först i Christoffer Erikssons träning och sedan för Vitale Ciotala.</p>



<p>Totalt gjorde hästen 37 starter och vann sex av dessa, varav Prix de Saint-James (€75.000), Prix d’Alencon (€57.000) och Prix de Sartilly (€57.000) på Vincennes. I prispengar inbringade äventyret över tre miljoner kronor!</p>



<p>Senaste starten i Frankrike gjordes för drygt ett år sedan och sedan i somras tränar Lena Elfving valacken i Sverige. Igår kväll på hemmabanan Solänget var det dags för första segern. I en supersprint över 1.140 meter under sadel slog Self Explosive till och vann på 1.10,3a tillsammans med Caroline Linder.</p>



<p>40.000 kronor var förstapriset och lika mycket inkasserade Jan-Olov Persson-tränade <strong>B.W.Rune</strong> (e. Tekno Odin) när han vann kallblodens supersprint på 1.21,4a. I segersadeln satt Nathalie Blom.</p>



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



<p class="has-drop-cap">7En dansk höjdare på höstkanten är ”Derbyrevanscherna” Aalborg Stora Pris och Aalborg Hoppechampionat för fyraåringar. På fredag-lördag avgörs de båda storloppen.</p>



<p>Däremot får de dansktränade fyraåringarna ingen chans till revansch på Derbyvinnaren. Johan Untersteiner står nämligen över loppet med <strong>Lazy Dust</strong> (e. Brillantissime) och väljer en annan matchningsväg i höst, där hästen är anmäld till både Europaderbyt och svenska Breeders Crown. Inte heller Christoffer Erikssons Derbyfyra <strong>La Liga Boy</strong> (e. Donato Hanover) startar i Ålborg.<br>Tvåan och trean från danska Derbyt finns bland hästarna i lördagens storlopp,<strong> Lee Marvin</strong> (e. Nuncio) och <strong>Ludvig Cash</strong> (e. Power).</p>



<p>De två fyraåringsloppen har dock fått sänkta förstapris i år. 100.000 danska kronor (125.000 kr ifjol) väntar vinnaren i öppna klassen, medan stona tävlar om en segercheck på 62.500 danska kronor istället för fjolårets 75.000 kronor.</p>



<p><strong>Startlista Aalborg Stora Pris, lördag</strong><br>2.140 meter autostart<br><em>Häst – Kusk</em></p>



<ol class="wp-block-list">
<li>Lemmy – Patrick Larsen</li>



<li>Labour Spring – Knud Mönster</li>



<li>Lookerbie Diamond – Flemming Jensen</li>



<li>L.O.C. – Morten Juul</li>



<li>Leo Wynn – Jeppe Juel</li>



<li>Lonesomerider – Jan Dahlgaard</li>



<li>Licorice Cash – Morten Friis</li>



<li>Look Like Gaagaa – Kristian Malmin</li>



<li>Lanson – Jörgen Sjunnesson</li>



<li>Lee Marvin – Birger Jörgensen</li>



<li>Ludvig Cash – Rene Kjær</li>
</ol>



<p><strong>Startlista Aalborg Hoppechampionat, fredag</strong><br>2.140 meter autostart<br><em>Häst – Kusk</em></p>



<ol class="wp-block-list">
<li>Lorraine – Jörgen Sjunnesson</li>



<li>Lets Go Ostedantik – Birger Jörgensen</li>



<li>Late Night – Flemming Jensen</li>



<li>Laurentia Mosebo – Knud Mönster</li>



<li>Lady Zola – Johan Kringeland Eriksen</li>



<li>Love Caviar – Patrick Larsen</li>



<li>Lipa Wee – Casper M. Nielsen</li>



<li>Leonora By Hans – Ruben Kristensen</li>



<li>Lux – Jeppe Juel</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
”Bestämmer själv när han är tillbaka”
Status för opererad världsrekordhållare. Snabbaste vinnarna i Unionskampen. Italiensk treåring i Wäjersten-debut. Dubbel SM-vinnare jagar final. Svenskfödd på fransk mixedauktion. Bröt lång segerlös svit i 1.140-meterslopp.
Detta och mer bland tisdagens nyheter.
Detta och mer bland tisdagens nyheter.
