
<p class="has-drop-cap wp-block-paragraph">1På lördag är det dags för 23:e upplagan av Orebro Int’l, som alla år utom ett avgjorts över drygt tre varv med hästar på flera volter. Undantaget var 2007, då loppet namngav gulddivisionsfinalen över medeldistans när Finders Keepers segrade.</p>



<p class="wp-block-paragraph">Och var har då vinnaren hittats genom åren när det handlat om styrkeprovet? Ja, det är minst sagt jämnt fördelat mellan de tre startvolterna.</p>



<ul class="wp-block-list">
<li><strong>3.140 meter (6 vinnare): </strong>Count Go, In Cap n’Gown, Dude Kemp, Balfour, Just Wait And See, Falcon Eye.</li>



<li><strong>3.160 meter (7 vinnare): </strong>Equator Damhus, Max Flukt, Imola November, Mellby Viking, Mack Dragan, Electrical Storm, Versace Face.</li>



<li><strong>3.180 meter (8 vinnare): </strong>Spring Erom, Juggle Face, Spring Erom, New Line, On Hold, Mellby Viking, Moni Viking, High On Pepper.</li>
</ul>



<p class="wp-block-paragraph">Två hästar har två titlar i loppet, <strong>Spring Erom</strong> (e. Gentle Star) och <strong>Mellby Viking</strong> (e. Viking Kronos), och bland de 15 deltagarna i årets upplaga finns fjolårsvinnaren<strong> High On Pepper</strong> (e. Ready Cash), som startar i loppet för tredje året i rad.<br>För två år sedan slutade Katja Melkkos travare trea innan triumfen kom vid utklassningssegern ifjol på tangerade löpningsrekordet 1.13,3/3.180 meter tillsammans med Jorma Kontio. Den tiden travade även 2017 års vinnare <strong>Balfour</strong> (e. Scipion du Goutier) och Robert Bergh.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/04/26v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Örebros V75-tävlingar på lördag.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Efter en påskhelg med många strålande prestationer på travbanorna och avslutningen på Åby med toppfyraåringar i försöken till Kunga- och Drottningpokalen, så är vardagen här. Två svenska banor har tävlingar och huvudbanan är Boden (första start 18.20).</p>



<p class="wp-block-paragraph">Treåringsloppet går inte av för hackor. Sex av sju deltagare har redan vunnit lopp och den sjunde är <strong>Mervellieux Sisu</strong> (e. Bold Eagle) som inlett med två andraplatser. Treåringen är lillebror till tre miljonärer, tillika storloppsvinnare, i <strong>Dixi Sisu</strong> (Svampen), <strong>Just Perfect Sisu</strong> (Jarlsberg Grand Prix) och <strong>Lilium Sisu</strong> (norska Stokriteriet och Oaks). Petri Salmela tränar den sistnämnda och Mervellieux Sisu.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/petrisalmela-617x333.jpg" alt="" class="wp-image-352655"/><figcaption class="wp-element-caption">Petri Salmela. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Bland de sex som segrat finns en Bodendebutant i <strong>Ethel Face </strong>(e. Gotland). Hon ropades in på Travera för en månad sedan för 430.000 kronor av Rutqvist i Boden AB och gör nu debut i Jaakko Alamäkis regi. Ethel Sisu har varit etta och tvåa i livets två starter och travade 1.15,1m i sista starten i Adrian Kolgjinis regi.</p>



<p class="wp-block-paragraph">För 28 år sedan avled proffstränaren Rolf Sundling från Boden i en olycka. Sedan 1997 har hans minne hedrats på hemmabanan med ett minneslopp.<br><em>”Rolf Sundling var så mycket mera än bara travtränare. Kalla honom gärna för hedersman och en hästkarl lite av den gamla stammen,”</em> skriver Bodentravet i programmet till kvällens tävlingar. I årets upplaga möts 14 kallblod i en spårtrappa över medeldistans, där hemmatränaren Roger Nilsson luftar segermaskinen <strong>Sjöli Morten</strong> (e. Dotterud Teddy), som vunnit tio av 23 starter, men gjorde bort sig med galopp i årsdebuten.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Ett flerklasslopp för kallblod sticker ut på tisdagens lunchbana Hagmyren (första start 12.20). Hemmatränaren Jan-Olov Persson tränar tre av 13 hästar i loppet, däribland fjolårets Derbyfyra <strong>Eld Vide C.G.</strong> (e. Tekno Eld) och <strong>Re Vital</strong> (e. Ingbest), som inte varit sämre än tvåa på årets åtta starter. Det slutade han i just senaste starten, dubbelcupsfinalen i Bollnäs för 2,5 veckor sedan.</p>



<p class="wp-block-paragraph">Men Perssons trio har en tuff utmanare i Lars Wikström-tränade segermaskinen <strong>Brageson</strong> (e. Lome Brage), som har har några få kronor kvar till miljongränsen och har vunnit 17 av 39 starter i karriären. Han kom till Wikström för 1,5 år sedan och största segern kom i en dubbelcupfinal för ett år sedan.<br>Brageson tjänade över en halv miljon under fjolårssäsongen och nu blir det årsdebut för nioåringen, som inte tävlat sedan början av november. Ludwig Wickman får chansen i vagnen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/04/250422.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Spring Race med V75 i dagarna fyra avslutades på påskdagen och omsättningsmässigt blev det ett stort ras de fyra dagarna med hela 36.572.072 kronor. Nästan hela tappet kommer på den stora multijackpotdagen på Romme, som backade med 35 miljoner jämfört med 2024.</p>



<p class="wp-block-paragraph">Förklaringen är enkel. Förra året låg närmast osannolika 85 miljoner kronor extra i sjurättspotten till jackpotdagen. I år hade det ”bara” samlats ihop 24,5 miljoner.</p>



<p class="wp-block-paragraph">En annan faktor kan vara att förra året hölls V75 Spring Race den 28-31 mars, precis efter löning, medan årets V75 Spring Race ligger innan aprillönen betalas ut för många.</p>



<p class="wp-block-paragraph"><strong>Omsättning V75 Spring Race</strong><br><em>Dag, bana – Omsättning 2024 – Omsättning 2025</em></p>



<ul class="wp-block-list">
<li>Skärtorsdag, Gävle – 25.065.526 kr – 25.757.223 kr</li>



<li>Långfredag, Färjestad – 30.445.378 kr – 28.243.867 kr</li>



<li>Påskafton, Klosterskogen – 50.384.912 kr – 50.345.441 kr</li>



<li>Påskdagen, Romme – 144.448.204 kr – 109.425.417 kr</li>



<li>Summa – 250.344.020 kr – 213.771.948 kr</li>
</ul>



<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/07/v.g.voittokungstravet-617x333.jpg" alt="" class="wp-image-614699"/><figcaption class="wp-element-caption">V.G.Voitto och Ari Moilanen vann alla tre avdelningar av Kungstravet i Jyväskylä. Foto Terhi Piispa-Helisten</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Solvallas Elitloppsgeneral Anders Malmrot har bjudit in sju hästar till Elitloppet, men fortfarande håller han i biljetterna till kallblodens Elitkamp med en miljon kronor till vinnaren. Där bjuds två hästar vardera in från Sverige, Norge och Finland, medan det finns platser att tävla om både i Bollnästravets Elitsprint på fredag (anmälningstiden går ut idag kl 09.00) och i Erkon Pokaali på Vermo den 4 maj.</p>



<p class="wp-block-paragraph">Den nye finske kallblodskungen <strong>V.G.Voitto</strong> (e. Viesker), 1.18,2ak*/€441.200, är en drömhäst för Anders Malmrot. Han utsågs till Årets Häst i Finland förra året och har vunnit 26 av 43 starter. Rekordet 1.18,2a/1.609 meter sattes när han vann i Mikkeli i somras. Han tog hem Kungstravet genom att vinna alla tre avdelningarna.<br>I lördags i skuggan av Borups Victorys uppvisning i Seinäjoki Race gjorde V.G.Voitto årets andra start och det slutade som i årsdebuten med seger. Blott halv längd skiljde dock till tvåan <strong>Stallone</strong> efter att V.G.Voitto körts i ledningen i lågt tempo. Avslutningen var dock desto vassare och hästen travade runt 1.20 sista kilometern när han höll undan till seger på 1.22,6a/2.100 meter och inkasserade 6.000 euro.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Sveriges segerrikaste kusk Mats E Djuse ska köra kusk-VM i Nya Zeeland i november. Dessutom planeras en andra upplaga av Djuses utmaning på Östersundstravet, där Mats tillsammans med bröderna Mattias, Martin och Magnus och åtta inbjudna kuskar gör upp. Denna ska köras den 8 augusti, dagen innan Jämtlandsbanans nya storloppsdag i augusti med Jämtlands Stora Pris, Svenskt Kallblodsderby och Derbystoet lördag den 9 augusti.</p>



<p class="wp-block-paragraph">Nu är Mats klar för ytterligare en kuskmatch – i Norge. Det rapporterar norska Trav- og Galopp-Nytt. Landets nyaste bana Orkla Arena, som ersatte Trondheimsbanan Leangen och bjudit in Djuse att möta fjolårets champion på banan Dag-Sveinung Dalen och ytterligare tio norska kuskar söndag den 27 april. Minst tre lopp ska kora vinnaren i den kuskmatchen.</p>



<p class="wp-block-paragraph"><strong>Deltagare i kuskmatch på Orkla Arena:</strong><br>Mats E Djuse, Dag-Sveinung Dalen, Veronika Bugge, Jomar Blekkan, Thomas Mjöen, Arve Sjoner, Boye Ölstören, Noralf P Braekken, Inge Melby, Erik Braekken, Atle Solhus och Jarle Morten Sörmo.</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/2025/04/apassolindesbergyoutube-617x333.jpg" alt="" class="wp-image-709192"/><figcaption class="wp-element-caption">William Linberg vann direkt i sin första start som kusk när han styrde den av pappa Åke tränade Apasso till vinst i Lindesberg. Skärmbild Lindesberg Youtube</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">723-årige William Lindblom körde sitt livs första lopp i ett av två ungdomslopp med stora travare i samband med Lindesbergs ponnyloppsdag igår. Det slutade på bästa sätt för sonen till Örebroproffset Åke Lindblom. William lotsade nämligen pappatränade miljonären <strong>Apasso</strong> (e. Quite Easy till lätt vinst från tre tillägg, även om det strulade 700 meter från mål när Apasso tappade fart då han hakade i en konkurrent.</p>



<p class="wp-block-paragraph">När han kom loss flög Apasso fram jämfört med konkurrenterna och kom hem på 1.16,9/2.200 meter vid seger med 2,5 längder.<br>– Det känns väldigt bra. Det blev lite stört, men löste sig till slut. Det är en bra häst. Jag har fått mycket träning hemma och nu måste det bli fler lopp efter det här, sade William Lindblom i segerintervjun.</p>



<p class="wp-block-paragraph">Det var Sverigepremiär för ungdomslopp (högst 25 år) med stora hästar på en ponnydag och intresset var så pass stort att det blev två lopp istället för tilltänkta ett lopp i Lindesberg.</p>



<p class="wp-block-paragraph">Det andra ungdomsloppet vanns av <strong>Ashanti Bi</strong> (e. Equinox Bi) och Victor Ekblom, som tog sin första kuskseger i nionde försöket.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Bästa startvolten i Orebro Int’l
Titelförsvararen är redo i Örebro. Raset för V75 Spring Race. Djuse i norsk kuskmatch. I väntan på första kallblodsbiljetten…
Detta och mer bland tisdagens nyheter.
Detta och mer bland tisdagens nyheter.
