
<p class="has-drop-cap">1 Det är i Borlänge, på <strong>Romme</strong> (start 18.20) det händer idag. Snabbloppet med fem startande hästar där medelåldern är fem är ett av kvällens mest intressanta lopp. Inte minst för att det handlar om fem riktigt bra hästar som går ut i medeldistansloppet och mest intressant blir det att följa Daniel Wäjerstens femåring <strong>Bullet The Bluesky</strong> (e. Readly Express), som återkommer efter åtta månaders tävlingsfrånvaro.</p>



<p>Bullet The Bluesky siktades mot de stora loppen i Paris i vintras och har enligt tränare Wäjersten varit klar för start den senaste månaden. På Romme börjar uppladdningen mot en ny vinter i Paris och det är knappast någon vild gissning att Prix d’Amérique är det givna målet.</p>



<p>Hemmahästen <strong>Phantom Express</strong> (e. Readly Express) gör första starten sedan Åby Stora Pris och comeback på svensk mark handlar det om för <strong>Competivo</strong> (e. Bird Parker)<strong>. Izod Zet</strong> (e. Propulsion) och <strong>Mountcastle</strong> (e. Muscle Hill) är de övriga deltagarna i loppet som erbjuder 40.000 kronor till vinnaren.</p>



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



<p class="has-drop-cap">2 &#8221;Plåt-Sven&#8221;, eller Sven E S Andersson som var hans riktiga namn, var under många år en stor tränarprofil med bas på gården nära Ludvika i södra Dalarna och gjorde sig ett namn med <strong>Abbey Rozz</strong> (e. Armbro Nick), som köptes som en trashank i mitten av 1980-talet med några tusenlappar på priskontot. När karriären var över hade hästen sprungit in över 2,5 miljoner kronor.</p>



<p>Annars var det med flera unghästar under 2000-talet som Sven kom att skörda stora framgångar. Den främste var <strong>Seth Bowl</strong> (e. Born Quick), som när karriären summerats hade sprungit in över sex miljoner kronor och vunnit både E3 och Europeiskt Treåringschampionat.</p>



<p>I Italien köptes bröderna <strong>Calypso Capar</strong> (e. Supergill), som vann uppfödningsloppet Gran Premio Allevatori i Rom som tvååring 2001, och <strong>Lord Capar</strong> (e. Varenne). 16 segrar på 21 starter som två- och treåring, däribland Gran Criterium i Milano 2007 och Ulf Thoresens Minneslopp året efter.</p>



<p>&#8221;Plåt-Sven&#8221; avled julen 2008 i en ålder av 77 år och sedan 2009 hedras han med ett minneslopp för treåringar på Romme.</p>



<p>Tolv hästar gör upp om 100.000 kronor i förstapris i årets upplaga av Plåt-Svens Minne och Katja Melkko, Jörgen Westholm och Daniel Wäjersten har alla två hästar var med i loppet. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/cashmanjrrnsm260709adamstromstalltz-617x411.jpg" alt="" class="wp-image-872405"/><figcaption class="wp-element-caption">Cashman J.R. vinner Juliloppet i Örebro. Han är snabbaste vinnaren i Plåt-Svens Minne. Foto: Adam Ström/stalltz.se</figcaption></figure>



<h2 class="wp-block-heading">Snabbaste vinnare i Plåt-Svens Minne</h2>



<p>Häst (far) – Tränare – Segertid – År</p>



<ul class="wp-block-list">
<li>Cashman Jr (e. Fourth Dimension) – Roger Walmann – 1.12,5a/2.140 – 2024</li>



<li>Coral Coger (e. Ken Warkentin) – Ola Åsebö – 1.13,5a/2.140 – 2023</li>



<li>Boston Wise L (e. Main Wise As) – Timo Nurmos – 1.13,7a/2.140 – 2020</li>



<li>Pure Muscle (e. Muscle Hill) – Reijo Liljendahl – 1.13,7a/2.140 – 2022</li>



<li>Mon Amour d’Aurcy (e. Greenshoe) – Björn Goop – 1.13,7a/2.140 – 2025</li>
</ul>



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



<p class="has-drop-cap">3 Startfältet till Dam-SM i Eskilstuna den 4 oktober med 150.000 kronor i förstapris blir klart ikväll när det sjätte och sista uttagningsloppet körs i <strong>Skellefteå</strong> (start 18.30) för kuskar med licens på Boden, Skellefteå och Umeå. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/tekla6-617x333.jpg" alt="" class="wp-image-883687"/><figcaption class="wp-element-caption">Sandra Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Det ser upplagt ut för att Bodenekipaget <strong>Gratisfaction</strong> (e. Propulsion) och Sandra Eriksson kan ta hem det sista försöket till Dam-SM. Gratisfaction har STL-meriter att luta sig mot och står helt klart för klassen i kvällens gäng.</p>



<p>I finalen lottas de sex försöksvinnarna på spår 1-6, medan tvåorna får spår 7-12.</p>



<h2 class="wp-block-heading">Inkvalade till Dam-SM 2026:</h2>



<p>Häst – Kusk, hemmabana</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>



<li>Com Isidor – Susanne H Osterling, Solänget</li>
</ul>



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



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



<li>Sommarflörten – Julia Nilsson, Färjestad</li>



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



<li>Can’t Be Ruled – Felicia Molin, Gävle</li>



<li>Prop Line W. – Jill Ivarsson</li>
</ul>



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



<p class="has-drop-cap">4 Vi börjar i Värmland idag. Årjäng (start 12.20) erbjuder lunchtävlingar till spelarna och treåringsloppet som ingår i V4-spelet har samlat en rad lovande travare till start.</p>



<p>Geir Vegard Gundersens <strong>Nogal Mearas</strong> (e. Muscle Hill) debuterade med seger på 1.15,1/2.140 meter i just Årjäng förra månaden och idag är det första gången bakom bilen som gäller för treåringen. Robert Berghs <strong>Omark</strong> (e. Chelsea Boko) har två vinster på sex starter och är en av de hårdaste konkurrenterna till Gundersens häst idag.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/09/260918.pdf" target="_blank" rel="noreferrer noopener">Startlistor till dagens tävlingar hittar du här.</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/2025/10/storybooklove10242025newimagemedia1024px-617x347.jpg" alt="" class="wp-image-785614"/><figcaption class="wp-element-caption">Storybook Love och Todd Ratchford. Foto: New Image Media</figcaption></figure>



<p class="has-drop-cap">5Ikväll körs två uttagningslopp till Elegantimage ($35.000) för treåriga ston på Woodbine och finalen som har C$375.000 i prissumma avgörs på samma bana lördagen den 26 september.</p>



<p>Melander, Svanstedt, Takter. Vi börjar bli vana med det svenska deltagandet när det drar ihop sig till storlopp i Nordamerika och självklart finns nyss nämnda tränare på plats i Ontario ikväll. </p>



<h2 class="wp-block-heading">Elegantimage, försök 1</h2>



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



<ol class="wp-block-list">
<li>Upto Laura Hanover (e. Captain Corey) – Laura Toscani</li>



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



<li>Sugar Packet (e. Six Pack) – Blake MacIntosh</li>



<li>Storybook Love (e. Chapter Seven) – Matt Bax</li>



<li>R Ro (e. Chapter Seven) – Susanne Kerwood</li>



<li>Leading Lady (e. Walner) – Nancy Takter</li>



<li>Sparks (e. Walner) – Åke Svanstedt</li>



<li>Pats Queen (e. Father Patrick) – Rodney Hughes</li>



<li>Courtney’s Promise (e. Tactical Landing) – Rick Zeron</li>
</ol>



<h2 class="wp-block-heading">Elegantimage, försök 2</h2>



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



<ol class="wp-block-list">
<li>Lainey W (e. Bar Hopping) – Marcus Melander</li>



<li>Ill Have the Red (e. Chapter Seven) – Rick Zeron</li>



<li>Cher Hill (e. Muscle Mass) – Gregg McNair</li>



<li>Kngtstlkrs Games (e. Calgary Games) – Peter Shody</li>



<li>Th Trix R Forkids (e. Muscle Mass) – Murray Brethour</li>



<li>Busy Miss Lissy S (e. Calgary Games) – Åke Svanstedt</li>



<li>Sharp Seven (e. Chapter Seven) – George Ducharme</li>



<li>Denarius (e. International Moni) – Nancy Takter</li>



<li>Shimmering Hanover (e. Captain Corey) – Luc Blais</li>
</ol>



<p>Till Canadian Trotting Classic (C$590.000) körs inga uttagningar, utan fältet är spikat och finalen körs direkt den 26 september. Spåren är däremot inte klara.</p>



<h2 class="wp-block-heading">Canadian Trotting Classic 2026</h2>



<p>Häst – Tränare</p>



<ul class="wp-block-list">
<li>AI – Ron Burke</li>



<li>Apex – Marcus Melander</li>



<li>Highland Destiny – Nancy Takter</li>



<li>Magic Punk –Åke Svanstedt</li>



<li>Nix Nacken – Marcus Melander</li>



<li>Strobe Lite – Ben Baillargeon</li>



<li>Touchedbyanangel – Kyle Fellows</li>



<li>Yankee Boost – Gregg McNair</li>
</ul>



<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/2026/07/scoopdyga125748001-617x411.jpg" alt="" class="wp-image-870893" style="width:595px;height:auto"/><figcaption class="wp-element-caption">Jackpot Mearas och Dwight Pieters vid segern i Frankrikedebuten. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap">6 Vinst igår och möjlighet till ny triumf idag. Två av tre. Det är facit för <strong>Jackpot Mearas</strong> (e. Muscle Hill) i dennes starter på fransk mark och efter förra veckans övertygande triumf på Vincennes är Maria Törnqvists valack tillbaka på den franska huvudstadsbanan sju dagar senare.</p>



<p>Idag är det Prix Cleomede (€59.000) över 2.700 meter som gäller och det finns fler svenska inlag i loppet. Stall Courants<strong> Imperatur Am</strong> (e. Ready Cash) gör debut på fransk mark och i Erik Bondos regi. Åttaåringen har gjort 31 starter i livet och tolv av dem har slutat med seger. </p>



<p>Elva hästar finns med i kvällens lopp i Paris.</p>



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



<p class="has-drop-cap">7 Några kuskar har redan korats som champions i Sverige i år, men det finns banor där striden om championatet kan bli rafflande ända in på målsnöret. På Åby har det många gånger avgjorts i sista steget och det kan mycket väl bli så även 2026.</p>



<figure class="wp-block-image alignright size-full is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/08/johanuntersteiner2.jpg" alt="" class="wp-image-888329" style="aspect-ratio:1.851861349745694;width:447px;height:auto"/><figcaption class="wp-element-caption">Johan Untersteiner. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Johan Untersteiner</strong> håller grepp i ledningen, men det är vansinnigt tätt bakom honom där både <strong>Carl Johan Jepson</strong> och <strong>Stefan Persson</strong> kan gå om vilken bra arbetsdag som helst.</p>



<p>Dessutom är det inte nog med dessa tre kuskar. <strong>Björn Goop</strong> (18) och <strong>Robert Bergh </strong>(16) kanske inte känner sig avslagna helt i striden om kusktiteln.</p>



<p>Nästa år lär ytterligare ett stort kusk- och tränarnamn finnas med i den här listan i mitten av september; Daniel Wäjersten heter han.</p>



<h2 class="wp-block-heading">Championstrider med nerv 2026:</h2>



<ul class="wp-block-list">
<li><strong>Bergsåker</strong>: Mats E Djuse 51 – Daniel Wäjersten 47</li>



<li><strong>Dannero</strong>: Marcus Lilius 11 – Henrik Svensson 9</li>



<li><strong>Halmstad</strong>: Johan Untersteiner 27 – Stefan Persson 23</li>



<li><strong>Solänget</strong>: Marcus Lilius 6 – Tomas Pettersson 5 – Ulf Ohlsson 4</li>



<li><strong>Umåker</strong>: Ulf Ohlsson 9 – Mats E Djuse 8 – Marcus Lilius, Daniel Wäjersten, Jenny Engfors 7</li>



<li><strong>Åby</strong>: Johan Untersteiner 27 – Carl Johan Jepson 25 – Stefan Persson 24</li>
</ul>
