
<p class="has-drop-cap">1 Anders Wallins segermaskin <strong>Ulvsåsen</strong> (e. Åsajerven) har setts som en utmanare för den absoluta kallblodseliten under flera års tid, men tyvärr har alla segrar blandats med längre skadeuppehåll. Den senaste smällen kom förra sommaren när han skadade en böjsensa.</p>



<p>Men Ulvsåsen gjorde som han gjort många gånger förr, kom tillbaka som en vinnare och karriärens största triumf kom för en dryg månad sedan när han vann Svenskt Mästerskap på Bergsåker tillsammans med Ulf Ohlsson.</p>



<p>Men med hästens historisk fick säkerligen beskedet för ett par veckor sedan många att sätta kaffet i vrångstrupen. Ulvsåsen ströks från Unionskampen på grund av hälta.</p>



<p>Nu visade det sig vara av lindrigare art och ikväll i Rättvik (första start 18.20) är den svenske mästaren tillbaka på tävlingsbanan. Det sker i ett försök i dubbelcupen, vars final körs på hemmabanan Bergsåker den 8 november och där har Wallin tidigare rapporterat att han gärna är med.</p>



<p>Ulvsåsen ställs mot bland andra fjolårets dubble Derbyvinnare <strong>Frivoll Gorm</strong> (e. Ängsborken), som i fjärde starten för nye tränaren Jörgen Westholm tog första segern då han slog Majblomster under Bergsåkers kallblodskväll förra veckan. </p>



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



<p class="has-drop-cap">2 SM-vinnaren får inte plats i kvällens V64-omgång, som delas mellan Rättvik och Halmstad (start 18.30). Där dyker en högättad hingst upp efter uppehåll i en av Rättviks avdelningar. Fyraårige <strong>Lynam</strong> (e. Greenshoe) är lillebror till självaste Derbyvinnaren och Sveriges näst vinstrikaste sto genom tiderna, Joviality (e. Chapter Seven), 1.08,4ak/26.167.062 kr.</p>



<p>Lynam inledde själv tävlingskarriären som tvååring i USA, tävlade inte alls som treåring (struken två gånger) och gjorde Sverigedebut på allvar i Marcus Schöns regi i vintras. Två segrar på sex försök blev resultatet innan hästen tvingades till vila. Nu är han tillbaka efter närmare fem månaders uppehåll.</p>



<p>I Halmstad har David Persson hittat en passande uppgift för <strong>Let Me In </strong>(e. Bold Eagle), som gör första starten sedan han slutade oplacerad i tuffa Malmö Stads Pris på Åbergskvällen i juli. Nu finns han på tilläggsfållan i ett dubbelklasslopp och ställs mot beskedligare motståndare än vid sina senaste starter.</p>



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



<p class="has-drop-cap">3 Det tävlar friskt i Sverige denna fredag med fyra banor i elden och först ut är Eskilstuna (första start 12.20) med lunchtävlingar. </p>



<p>En delningsproposition upp till 1,6 miljoner kronor med vanlig spårlottning utgör sex åttondelar av lunchen och David Persson har häst till start även här. Fyraårige <strong>Orel Boko</strong> (e. Brillantissime) hittade stilen i slutet av sommaren och ståtar nu med tre raka segrar. Från femtespår bakom bilen inleds jakten på fjärde raka.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2021/03/davidpersson-617x333.jpg" alt="" class="wp-image-145964" style="width:677px;height:auto"/><figcaption class="wp-element-caption">David Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Eskilstuna, Mantorp, Umåker och Östersund valde när tävlingsplaneringen lades för 2025 att sprida ut prispotten och skapa extra tävlingsdagar med lägre prispengar. Ikväll är det dags för en sådan extradag i Östersund (start 17.45) med 15.000 kronor i förstapris i alla lopp utom snabbloppet, där vinnaren tar hem 20.000 kronor.</p>



<p>I det sistnämnda möts tre dubbelmiljonärer och en ”nästandubbelmiljonär” i <strong>Weekend Fun</strong> (e. Jaded), <strong>Coral Coger</strong> (e. Ken Warkentin), <strong>Dwayne Zet</strong> (e. Muscle Massive) och <strong>G.K.Justus</strong> (e. Brad de Veluwe).</p>



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



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/10/skarmavbild20241003kl.16.35.22-617x348.jpg" alt="" class="wp-image-642386" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Peter Untersteiner firar efter vinsten med Global Dubhe.</figcaption></figure>



<p class="has-drop-cap">4 Tyska storloppet Grosser Preis von Deutschland har anor från 1920, då Charlie Mills vann den första upplagan med österrikiske Derbyvinnaren <strong>Baka</strong>, vilken samma år tog hem Bild-Pokal. 2009 fick loppet ett lyft som internationellt fyraåringslopp och svenska tränare har firat enorma framgångar sedan dess.</p>



<p>Bara en gång på de senaste 16 åren har en häst som tränats utanför Sveriges gränser vunnit Grosser Preis von Deutschland: Rob de Vliegers <strong>Zorba Oldeson</strong>.</p>



<h2 class="wp-block-heading">Svensktränade vinnare i fyraåringsloppet</h2>



<p><em>År – Namn – Körsven (tränare)</em></p>



<ul class="wp-block-list">
<li>2009 – Nu Pagadi – Erik Adielsson (Stig H Johansson)</li>



<li>2011 – Tamla Celeber – Örjan Kihlström (Roger Walmann)</li>



<li>2012 – On Track Piraten – Jos Verbeeck (Hans R Strömberg)</li>



<li>2013 – Dream Take Time – Johnny Takter (Lars I Nilsson)</li>



<li>2014 – Riff Kronos – Veijo Heiskanen</li>



<li>2015 – Exodus Hanover – Kenneth Haugstad (Roger Walmann)</li>



<li>2016 – Cruzado Dela Noche – Per Linderoth (Stefan Melander)</li>



<li>2017 – Diamanten – Kim Eriksson (Robert Bergh)</li>



<li>2018 – Hesiod – Ulf Ohlsson (Petri Salmela)</li>



<li>2019 – Zarenne Fas – Rikard N Skoglund (Jerry Riordan)</li>



<li>2020 – Oscar L.A. – Joakim Lövgren</li>



<li>2021 – Toto Barosso – Peter Untersteiner</li>



<li>2022 – Indy Rock – Jörgen Sjunnesson (Johan Untersteiner)</li>



<li>2023 – Global Dubhe – Johan Untersteiner</li>
</ul>



<p>Ifjol bytte loppet – som sedan 2011 har Hamburg som hemvist – skepnad igen och blev ett fyra- och femåringslopp med två klasser, en för vardera kön, och det slutade med dubbel blågul succé. Peter Untersteiner vann hingstklassen med sonen Johans <strong>Global Dubhe</strong> (e. Brillantissime), medan Stefan Persson styrde Adrian kolgjini-tränade <strong>Karaboudjan</strong> (e. Walner) till vinst i stoklassen.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/07/13crownmal-617x333.jpg" alt="" class="wp-image-605153" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Daniel Redén-tränade Crown foch Erik Adielsson vid segern i Sprintermästaren. Foto Lars B Persson</figcaption></figure>



<p>Svenskarna står väl rustade även i årets upplagor med 25.000 euro till vinnarna. Johan Untersteiner tar ut Breeders Crown-vinnaren <strong>Stens Rubin</strong> (e. Readly Express) och han möter Daniel Redéns Sprintermästare <strong>Crown</strong> (e. Chapter Seven) och Mattias Djuses danske Derbyvinnare <strong>Icebreaker </strong>(e. Chocolatier).</p>



<p>Bland motståndarna finns tyske Derbyvinnaren <strong>Summermusic’snight S </strong>(e. Tactical Landing) och tvåan från samma löpning. <strong>Aladin </strong>(e. Baltimore As) gick på pumpen i Derbyt och det var hans första förlust i karriären.</p>



<p>I stonas uppgörelse startar Mattias Djuse <strong>Olivia Bros</strong> (e. Muscle Mass) och precis som bakom Icebreaker är det broder Magnus som tar hand om tömmarna.</p>



<p>Det är gott om svenska hästar i övriga lopp i Hamburg idag.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/10/03v5hamburg.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tävlingarna.</a></p>



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



<p class="has-drop-cap">5 Den riktigt stora travveckan i Lexington är som bekant igång och den avslutas med söndagens Kentucky Futurity för de treåriga hästarna.</p>



<p>Hela 39 tävlingsdagar körs på The Red Mile under årets meeting som startade den 20 juli och idag, fredag är det fokus på de tvååriga hingstarna och valackerna, som ska slåss i fyra avdelningar i International Stallion Stakes och som vanligt är svenskar i farten.</p>



<h2 class="wp-block-heading">$72.000 ISS</h2>



<p><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>Impossible Bi (e. Greenshoe) – Erv Miller</li>



<li>Midwind Chimp (e. Greenshoe) – Marcus Melander</li>



<li>Neighver Punt (e. Bar Hopping) – Marcus Melander</li>



<li>Kibbie J (e. Walner) – Noel Daley</li>



<li>Rambo Hanover (e. Muscle Hill) – Åke Svanstedt</li>



<li>Requiem (e. Muscle Hill) – Matthew Burkholder</li>



<li>Ultimate Betrayal (e. Calgary Games) – Noel Daley</li>
</ol>



<h2 class="wp-block-heading">$73.000 ISS</h2>



<p><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>Dollar Draft (e. Bar Hopping) – Noel Daley</li>



<li>Lethal Legacy (e. Muscle Hill) – Carter Pinske</li>



<li>Nix Nacken (e. Muscle Hill) – Marcus Melander</li>



<li>Hamlet Hall (e. Cantab Hall) – Norm Parker</li>



<li>Kountry Jim (e. Father Patrick) – Ron Burke</li>



<li>Nordic Dancer S (e. Six Pack) – Åke Svanstedt</li>



<li>Zephyr Kemp (e. Calgary Games) – Marcus Melander</li>



<li>Ardonne (e. Tactical Landing) – Megan Scrann</li>
</ol>



<h2 class="wp-block-heading">$73.000 ISS</h2>



<p><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>I’m Kronos (e. Walner) – Åke Svanstedt</li>



<li>Highball Hanover (e. Bar Hopping) – Noel Daley</li>



<li>Practical Man (e. Tactical Landing) – Jim Campbell</li>



<li>Silverstein (e. Chapter Seven) – Matthew Burkholder</li>



<li>Cambridge Hanover (e. Walner) – Andrew Harris</li>



<li>Maga Hill (e. Muscle Hill) – Ron Burke</li>



<li>Create Escape (e. Gimpanzee) – Åke Svanstedt</li>



<li>Inexpressable (e. Walner) – Lucas Wallin</li>
</ol>



<h2 class="wp-block-heading">$73.000 ISS</h2>



<p><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>Never Say Die (e. Muscle Hill) – Marcus Melander</li>



<li>Minoan (e. Bar Hopping) – Noel Daley</li>



<li>American Power (e. Walner ) – Marcus Melander</li>



<li>Oversear (e. International Moni) – Charlie Norris</li>



<li>Be Green (e. Greenshoe) – John Butenschoen</li>



<li>Captain Naughty (e. Captain Corey) – Justin Lloyd</li>



<li>Mr Penner (e. Captain Corey) – Åke Svanstedt</li>



<li>Onassis (e. Greenshoe) – Nancy Takter</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2023/10/takternancy230930adamstromstalltz-617x818.jpg" alt="" class="wp-image-506432" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Nancy Takter. Foto: Adam Ström/stalltz.se</figcaption></figure>



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



<p class="has-drop-cap">6 Danmarks bästa sto ska utses i Odense idag. 100.000 danska kronor väntar vinnaren av ”DM for Hopper” och det upplagt ut för Michael Lönborg, som har tre ston med i loppet och där han själv sitter upp bakom femåriga <strong>Juno</strong> (e. Great Challenger). </p>



<p>Loppet körs över 2.140 meter och det vimlar inte av namnkunniga hästar bland de tidigare vinnarna. <strong>Mathilde Tröjborg</strong> får nog anses vara den mest meriterade Sto-DM-vinnaren sedan loppets start 2006. Tomas Malmqvist står för den enda svensktränade vinnaren i loppet. 2013 segrade hans <strong>Ragna Opal</strong> (e. Mr Pine Chip) för Kasper K Andersen.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/08/ay2x1460kopier-617x411.jpg" alt="" class="wp-image-625448" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Juno och Michael Lönborg vinner Danskt Stoderby från ledningen. Foto: Kjeld Mikkelsen/K M Photo</figcaption></figure>



<h2 class="wp-block-heading">Startlista DM för ston</h2>



<p><em>Häst (far) – Körsven (tränare)</em></p>



<ol class="wp-block-list">
<li>Eagle Bat (e. From Above U.S.) – Jesper Becker</li>



<li>Hokita (e. Ens Snapshot) – John Köhler (Lönborg)</li>



<li>Go On Gardenia (e. Great Challenger) – Knud Mönster</li>



<li>Harper (e. Broadway Hall) – Jan Dahlgård (Lönborg)</li>



<li>Gabi Kyvsgård (e. From Above U.S.) – Casper M Nielsen (Korfitsen)</li>



<li>Juno (e. Great Challenger) – Michael Lönborg</li>



<li>Ivana Nordic (e. Explosive Matter) – Jeppe Juel</li>



<li>Iloveyou Butcher (e. Dominion Beach) – Birger Jörgensen (Jensen)</li>



<li>Farinellli Hastrup (e. Great Challenger) – Sören Demant Andersen</li>
</ol>



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



<p class="has-drop-cap">7 Olof Thorson slog till och vann Åbys första lopp under torsdagen och det var, som det tämligen ofta är i travsporten, en välregisserad triumf från ledarryggen. <strong>Johnny Lodden</strong> (e. Flocki d&#8217;Urzy) hette segervapnet och vad kunde vara mer passande än att Olof Thorson kunde triumfera på sin hemmabana bara dagar efter att hans far Ingvar gått bort. <br>&#8221;Det var ju lite typiskt att jag skulle vinna lopp nu när han gått bort&#8221;, konstaterade Thorson efter segern.<br>En välregisserad seger, som sagt.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/10/skarmavbild20251002kl.20.55.34-617x396.jpg" alt="" class="wp-image-775288" style="width:676px;height:auto"/><figcaption class="wp-element-caption">Olof Thorson efter segern på Åby igår.</figcaption></figure>
