
<p class="has-drop-cap">1Han var champion på Åby 19 av 20 år från 1943 till 1962 – och dessutom var han Sveriges segerrikaste körsven under tolv år! Idag hedras Algot Scott (1908-1964) med sitt minneslopp på Åby (första start 14.35).</p>



<p>Algot var den store dominanten på Åby under banans första decennier sedan han tagit över championrollen från läromästaren Ragnar Thorngren. Algot Scott vann 1.584 lopp efter att ha klivit in i tusenklubben med <strong>Frazer</strong> (e. Locomitive) redan 1957. Flest segrar tog Scott med <strong>Delphus</strong> (e. Bulwark), som vann 27 lopp.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/03/thorngrenscott-617x333.jpg" alt="" class="wp-image-415656"/><figcaption class="wp-element-caption">Ragnar Thorngren (t.v.) med sin tidigare lärling Algot Scott. Bilder från ”I sadel och sulky på Åby i 25 år.”</figcaption></figure>



<p>Algot Scotts Minne har körts sedan 1985, då Stig H Johanssons <strong>The Onion</strong> (e. Quick Pay) segrade på 1.13,1a/1.640 meter. Alla år utom fyra – varav de tre senaste – har loppet avgjorts över sprinterdistans, men även i år är det medeldistans som gäller. Dessutom har Algot Scotts Minne fått anta formen som dubbelklasslopp, där silver- och gulddivisionshästar möts i en spårtrappa.</p>



<p>Hemmatränaren Christoffer Eriksson har vunnit loppet både med egentränat och som lånekusk. 2020 lotsade han italiensktränade Cokstile (e. Quite Easy) till vinst och för tre år sedan var egne Rackham (e. Love You) segervapnet.</p>



<p>Hoppet i årets upplaga heter <strong>Xanthis Hilton</strong> (e. Nuncio), som kommer från tre raka starter i silverdivisionen och tillhör de mer betrodda idag.<br>– En fin häst som tävlar på bra nivå. Han fick en liten paus, men bakspår är missgynnande. Jag tror att han är bättre när han får vara med där framme direkt. Om han ska kunna vinna loppet måste man hitta en invändig resa och chansa lite, sade Christoffer Eriksson till V65 Direkt.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/03/21v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</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/2022/07/harpybergh-617x333.jpg" alt="" class="wp-image-334021"/><figcaption class="wp-element-caption">Robert Berghs Harpy vid seger på Solvalla som treåring. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">2Robert Bergh inledde året med fem segrar på 17 starter inklusive två triumfer i V85-lopp. Sedan tog han två månaders tävlingspaus. För en dryg vecka sedan drog tävlingssäsongen igång igen, men det började med nio segerlösa starter. Sedan bröts sviten. Igår kväll i Halmstad slog Bergh till med en spetsseger med <strong>Mysterious Love</strong> (e. A Mysterious Love) i Halmstad och kanske är det ett formbesked inför dagens tävlingar på Åby?</p>



<p>I Sulkysports expertpanel inför V85-omgången är förtroendet stort för Berghs danske topphäst <strong>Harpy</strong> (e. Bar Hopping) i Algot Scotts Minne.<br><em>”Klasshästen gjorde comeback så sent som i lördags och stod för en klart vettig prestation trots en tuff resa under loppets gång. Med den genomköraren i kroppen lär formen vara rejält framflyttad till lördagens start och grundkapaciteten är oomtvistad i dessa sammanhang. Även om motståndet är tufft när klasserna blandas så besitter han hårdheten som krävs för att kliva runt fältet om tempot blir det minsta uppskruvat. Jag tar ställning för att formhöjningen fäller avgörandet och lämnar honom ensam på mitt system,”</em> säger Patrik Kaldoyo på Spelpoolen i Strängnäs.</p>



<p>Och själv säger Bergh på sin hemsida:<br>– Godkänd årsdebut. Han var spänstig så bör vara förbättrad med loppet. Det blir vanlig sulky, barfota bak och mer stängt huvudlag.</p>



<p><a href="https://sulkysport.se/spelstugan/v85-tips-a-21-mars/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till V85.</a></p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/69ansspel/V85_2026-03-21_6_5">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V85_2026-03-21_6_5">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p><a href="https://www.atg.se/butik/simsalabim/V85_2026-03-21_6_5">Här finns andelar till V85 hos Simsalabim.</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/2026/03/inexessbleuaaadam-617x333.jpg" alt="" class="wp-image-824135"/><figcaption class="wp-element-caption">Inexess Bleu vinner finalen i UET Elite Circuit på Solvalla. Idag årsdebuterar han på Vincennes. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">3Som äldre valack med över 13 miljoner kronor på kontot är det bara att stryka ett streck över vintermeetinget på Vincennes. Så gjorde Laurent-Claude Abrivard med vinnaren av UET Elite Circuit-finalen på Solvalla i höstas, <strong>Inexess Bleu </strong>(e. Vittel de Brevol), 1.09,9am*/€1.272.720.</p>



<p>Idag på Vincennes är hästen tillbaka på banan för första gången sedan den 1 november.<br>– Inexess Bleu hade inget passande program i vinter, men har tränat på hela tiden. Allt ser bra ut, men han kommer inte att vara på topp direkt i comebacken, berättade kusken och tränarsonen Alexandre Abrivard nyligen.</p>



<p>I Prix du Bois de Vincennes (€90.000) – grunddistans 2.850 meter – ska <strong>Inexess Bleu </strong>(e. Vittel de Brevol), 1.09,9am*/€1.272.720, försöka plocka in 25 meter på namnkunniga travare som segermaskinen <strong>Ino du Lupin </strong>(e. Scipion du Goutier), Prix de Paris-trean <strong>Ibiki de Houelle </strong>(e. Love You), <strong>Cobra Killer Gar </strong>(e. Readly Express) och Prix des Centaures-vinnaren <strong>Kobayashi </strong>(e. Face Time Bourbon).</p>



<p>Förra året vann Inexess Bleu, förutom UET Elite Circuit, även Grand Prix de Wallonie (€150.000) i Mons plus att det blev sex segrar på Vincennes, däribland i Prix Kerjacques (€120.000) och Prix Chambon P (€120.000).</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/02/scoopdyga1239820351df3c106124f11f1a57b2eff7455a66f-617x411.jpg" alt="" class="wp-image-822869"/><figcaption class="wp-element-caption">Jobspost. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap">4Förra veckan skulle Prix de Pierrefitte-sur-Seine (€68.000) ha avgjorts på Enghien med Jörgen Westholm-tränade <strong>Jobspost</strong> (e. Readly Express) som en av 16 hästar i loppet, men så blev inte fallet. På grund av regn avbröts tävlingsdagen på Paris-banan.<br>Istället är det dags att köra loppet idag på Vincennes, med ny anmälan, nya förutsättningar och nya startspår. För Jobsposts del innebar det ingen större skillnad. Han skulle ha haft bakspår på Enghien och startar från spår 13 bakom bilen på Vincennes idag.</p>



<p>Jörgen Westholms sjuåring visade sig ha extremt svårt för det franska voltstartsystemet och i de tre inledande loppen i Paris galopperade Jobspost, med seger ändå efter stark upphämtning i det tredje försöket på Vincennes. I bildebuten I senaste starten på kolstybben slog han till med seger på 1.09,7a/2.100 meter!<br>Mathieu Mottier körde i senaste starten och sitter i vagnen även nu, där Jobspost möter tre andra svenskbekantingar. <strong>Cool Kronos</strong> (e. Readly Express) drog innerspår, medan Jimmi Ehlers <strong>Certainly </strong>(e. Readly Express) och Stall Escapades <strong>General du Nord </strong>(e. Un Mec d’Heripre) startar i andra ledet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/01/scoopdyga123458014-617x411.jpg" alt="" class="wp-image-811473"/><figcaption class="wp-element-caption">Utvändige Chitchat kopplar grepp på invändige Ture L.A. kort före mål för två månader sedan. Foto: Scoopdyga</figcaption></figure>



<p>Ännu längre segerrad på Vincennes än Jobspost har Daniel Wäjersten-tränade nioåringen <strong>Chitchat</strong> (e. Maharajah). Med fyra raka segrar i bagaget kommer hästen idag ut i Prix Jean Cabrol (€75.000), där Benjamin Rochard sitter i vagnen precis som vid de fyra segrarna.<br>Chitchat ställs bland annat mot <strong>Indy Rock</strong> (e. Readly Express), som debuterar i Jörgen Westholms regi och svenskfödda <strong>Elegance Kronos</strong> (e. Muscle Hill).</p>



<p>I Prix d’Auxerre (€60.000) startar fjolårets svenske Derbysexa <strong>Fighter Kronos</strong> (e. Muscle Hill).</p>



<p><a href="https://www.letrot.com/courses/programme/2026-03-21/7500" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar.</a></p>



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



<p class="has-drop-cap">5 Han är mannen bakom tre av de främsta kallbloden i modern historia. Nu har norske uppfödaren, tränaren och hästägaren Jens A Wanvik lämnat jordelivet i en ålder av 85 år, men hans gärning i travsporten lever definitivt vidare.</p>



<p>Hans och hustrun Britts tre stora stjärnor var <strong>Bork Rigel</strong> (e. Alm Rigel), 1.20,4ak/13.695.673 NOK, <strong>Buaas Stjerna</strong> (e. Troll Jahn), 1.22,3ak*/3,741,859 NOK, och <strong>Röder</strong> (e. Alm Svarten), 1.20,6ak/3 967 221 NOK. Tillsammans gjorde de tre hästarna 709 starter och vann 252 lopp, en hel del av dem på svensk mark.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/05/borkrigelheat2-617x403.jpg" alt="" class="wp-image-92689"/><figcaption class="wp-element-caption">Bork Rigel och Jomar Blekkan. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p>Fantastiska 168 segrar på 345 starter blev resultatet på tävlingsbanan för Bork Rigel, som tog sin största seger i Svenskt Kallblodsderby i Östersund 1992. Samma lopp hade Buaas Stjerna vunnit året före i Östersund.<br>Bork Rigel fick drygt 400 avkommor och bland dem sex miljonärer, men sitt största avtryck i aveln gör han som morfar till championhingsten<strong> Bork Odin</strong>, pappa till färske världsrekordhållaren <strong>Brenne Borken</strong>, dubble Elitkampsvinnaren <strong>Tangen Bork</strong> och mångmiljonären <strong>Smedheim Solan</strong>.</p>



<p>Jens A Wanvik begravdes i onsdags.</p>



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



<p class="has-drop-cap">6Under nästan 20 år till och med 2023 var Momarken värd för en svensk V75-omgång årligen i mars, men sedan flyttades omgången till Bjerke. Ikväll är det dags för motsvarande tävlingsdag på Momarken (första start 19.12) med norskt V75-spel och för svensk del är det V65 som gäller.</p>



<p>Två anrika kallblodslopp avgörs med ändrade förutsättningar. Thor Östbys Minnelopp har tidigare varit ett lopp för äldre eliten – och avgjorts främst i december sedan 2003. Nu har det gjorts om ett fyraåringslopp och där luftar Öystein Tjomsland en av kandidaterna till norrmannens nionde raka (!) seger i Svenskt Kallblodsderby.<br><strong>Tangen Nils</strong> (e. Bork Odin) tillhörde kulltoppen som treåring utan att få den stora fullträffen. Han slutade tvåa i Biris Uppfödningslopp, trea i Kriteriet på Dannero och fyra i norska Kriteriet.<br>Han möter nu Kjetil Djöselands <strong>Brenne Bingo</strong> (e. Tekno Odin), som var tvåa i norska Derbyt.</p>



<p>Östfoldpokalen har också tidigare varit öppet för alla. Nu är loppet stängt vid 1,4 miljoner för hingstar och valacker, medan det är öppet för alla ston. I sistnämnda kategorin finns segermaskinen <strong>Voje Lotta</strong> (e. Ängsborken), som tjänat 2,9 miljoner och vunnit 20 av 35 starter.</p>



<p>Ett liknande lopp på varmblodssidan ser Frode Hamres flerfaldiga miljonärskor <strong>Don’t Say Gar</strong> (e. Varenne) och <strong>Bunny</strong> (e. Born In the U.S.A.) möta betydligt mindre meriterade killar.</p>



<p><a href="https://www.travsport.no/travbaner/momarken-travbane/startlist/2026-03-21" target="_blank" rel="noreferrer noopener">Här är startlistorna till Momarkens tävlingar.</a></p>



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



<p class="has-drop-cap">7Det blir svensktätt i Finland i eftermiddag, men inte i Rovaniemi vid polcirkeln som planerat utan i Uleåborg. På grund av banförhållanden har nämligen tävlingarna flyttats drygt 20 mil söderut.</p>



<p>Fem av tolv hästar i snabbloppet Arctic Heat King (€13.200) tränas nämligen på svensk mark. Skellefteåamatören Bert Pettersson mönstrar fältets vinstrikaste häst i femfaldige miljonären <strong>Selmer I.H,</strong> som kommer från vinst i ett annat grannland, i norska Harstad. Selmer I.H. drog dock bakspår, spår elva, medan stallkamraten <strong>Bravo Sabotage</strong> inleder från innern.<br>Dubbla chanser har även Bodenproffset Hanna Olofsson, som själv kör fransosen <strong>Humble Stance</strong> och sätter upp Jenny Engfors bakom <strong>The Oak L.A</strong>.<br>Det svenska laget kompletteras med Sandra Eriksson-tränade <strong>King of Djazz</strong>, som får finske championkusken Santtu Raitala i vagnen.</p>



<p>I de övriga loppen hittas Hanna Olofssons trio <strong>Oak L.A.</strong> (e. The Bank), <strong>Uno</strong> (e. Nuncio), <strong>Bornunderthunder</strong> (e. Flocki d’Aurcy), medan Bodenkollegan Janita Luttunen startar <strong>Francis Coccola</strong> (e. Beer Summit) och <strong>Time Match</strong> (e. Maharajah).</p>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5ST18yMS4wMy4yMDI2LnBkZg%3D%3D&#038;m=DUDGstEJ33jNcRabxqhP%2Bm62BMI%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till alla lopp i Uleåborg.</a></p>



<p><strong>Startlista Arctic Heat King (€13.200)</strong><br>2.140 meter autostart.<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Bravo Sabotage</strong> (e. From Above) – Jukka Torvinen</li>



<li><strong>Marlon Boko</strong> (e. Trixton) – Jarmo Saarela</li>



<li><strong>Adde S.H.</strong> (e. Nu Pagadi) – Niko Jokela</li>



<li><strong>Time Match</strong> (e. Maharajah) – Hannu Torvinen</li>



<li><strong>Marchall Match</strong> (e. Zola Boko) – Ville Koivisto</li>



<li><strong>The Oak L.A. </strong>(e. The Bank) – Jenny Engfors</li>



<li><strong>Humble Stance</strong> (e. Repeat Love) – Hanna Olofsson</li>



<li><strong>No Limit Royalty</strong> (e. R.C.Royalty) – Ville Pohjola</li>



<li><strong>Felix Orlando</strong> (e. Orlando Vici) – Tuukka Varis</li>



<li><strong>King of Djazz</strong> (e. Zola Boko) – Santtu Raitala</li>



<li><strong>Selmer I.H. </strong>(e. Love You) – Tuomas Pakkanen</li>



<li><strong>Ray Boy</strong> (e. Mr Pine Chip) – Kari Alapekkala</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Christoffer i Scotts fotspår
Sveriges segerrikaste kusk i tolv år hedras. Christoffer smyger till tredje segern? Fransk stjärna gör årsdebut. Jobspost och Chitchat förlänger segerraderna på Vincennes? Mannen bakom Bork Rigel död. Svenskar drar till Finland.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
