
<p class="has-drop-cap">1 En av vinterns stora snackhästar med fem raka segrar från februari till april, men ingen start på sex månader. Ikväll i Mantorps stora treåringslopp Sikta Mot Stjärnorna är Claes Sjöström-tränade <strong>Icy Conditions</strong> (e. Calgary Games) tillbaka på tävlingsbanan igen.</p>



<p>Årets segerrad är intakt efter bland annat dubbla triumfer i Margaretas Tidiga Unghästserie och Vårfavoriten för ston på Solvalla och totalt har fem starter inbringat 920.000 kronor.</p>



<p>Icy Cinditions har förstås de bästa meriterna i startfältet, men Thomas Bos har ett vasst kort i <strong>Raidhour Newport</strong> (e. Kadabra), som tävlat duktigt i sommar och närmast kommer från vinst i ett treåringslopp på Solvalla.</p>



<p>Sikta Mot Stjärnorna är sedan 2021 ett enskilt lopp med anmälan. Tidigare kördes ett koppel försök under säsongen som banade väg för finalen. Förstapriset är i år sänkt till 175.000 kronor efter att ha haft 300.000 kronor till vinnaren sedan 2021-2024.</p>



<h2 class="wp-block-heading">Snabbaste vinnarna av Sikta Mot Stjärnorna:</h2>



<p>År/häst (far) – Kusk (tränare) – Segertid (2.140 meter auto)</p>



<ul class="wp-block-list">
<li>2023 <strong>Immortal Doc</strong> (e. Brillantissime) – Carl Johan Jepson (Fredrik Wallin) – 1.12,5a</li>



<li>2019 <strong>Guzz Mearas</strong> (e. Muscle Mass) – Johan Untersteiner – 1.12,9a</li>



<li>2025 <strong>My Creation </strong>(e. Hohneck) – Rikard N Skoglund (Katja Melkko) – 1.13,1a</li>



<li>2020 <strong>Balsamine Font</strong> (e. Filipp Roc) – Björn Goop – 1.13,2a</li>



<li>2014 <strong>Explosive de Vie</strong> (e. Explosive Matter) – Jim Oscarsson – 1.13,3a</li>



<li>2015 <strong>Rhapsody Ås</strong> (e. Infinitif) – Örjan Kihlström (Roger Walmann) – 1.13,3a</li>



<li>2024 <strong>Ronno</strong> (e. Walner) – Ulf Ohlsson (Claes Sjöström) – 1.13,4a</li>



<li>2012 <strong>Mellby Apollo</strong> (e. From Above) – Per Lennartsson  – 1.13,6a</li>



<li>2017 <strong>Violet Bi</strong> (e. Equinox Bi) – Kevin Oscarsson (Jim Oscarsson) – 1.13,6a</li>
</ul>



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



<p class="has-drop-cap">2 <strong>Mantorp</strong> (första start 18.20) är måndagens huvudbana på svensk mark och vid sidan av Sikta Mot Stjärnorna finns fler godbitar. Som finalen av Månadsloppet, där det körts ungefär ett försök i månaden i olika klasser sedan slutet av mars och där nu elva hästar gör upp om 75.000 kronor i en spårtrappa.</p>



<p>Försöksvinnarna var <strong>Nicole Silvio</strong> (Fredrik Persson), <strong>Maverick</strong> (Fredrik Wallin), <strong>Sven Kuce</strong> (Thomas Madsen), <strong>Je t’Aime Legacy</strong> (Philip di Luca), <strong>King</strong> (Kenneth Haugstad) och <strong>Superstitious</strong> (Ulf Stenströmer). </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/svenkucegjm260628adamstromstalltz-617x414.jpg" alt="" class="wp-image-867867"/><figcaption class="wp-element-caption">Sven Kuce. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Av dessa är det endast toppfyraåringen <strong>Sven Kuce</strong> (e. Readly Express) som finns med i kvällens lopp. Thomas Madsens travare vann försök till Kungapokalen i våras, en avdelning Margaretas Tidiga Unghästserie i juni och ett Breeders Crown-försök i juli, men i Derbykvalet – som favorit – satte en snöplig galopp i utgången av slutsvängen stopp för Derbydrömmen.</p>



<p>Efter att ha fått strykas för hosta från ett bronsdivisionsförsök på Jägersro blir det nu återkomst i finalen av månadsloppet och Gustav Johansson sitter i vagnen.</p>



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



<p class="has-drop-cap">3 Femåriga stoet <strong>Old Maid Boko</strong> (e. Campo Bahia) vann sju lopp på 24 starter under tre säsonger hos Rick Ebbinge. För en månad sedan flyttades Old Maid Boko till Katja Melkko och svarade för en lysande debut i sin nya regi. I ett stolopp blåste hon till med seger på nya medelrekordet 1.12,2a/2.100 meter.</p>



<p>Idag inleds den svenska travveckan på <strong>Romme</strong> (första start 12.20) och Old Maid Hall dyker upp från passande innerspår mot hingstar och valacker.</p>



<p>Bland motståndarna finns Årjängstränaren Paw Mahonys norske Derbytrea <strong>Maserati Salt</strong> (e. Maharajah), som den här gången får Marcus Lilius i vagnen. Hästen svarade för en urstark avslutning till bronset i Derbyt, men har bara en seger på 23 starter hittills i karriären.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/10/261019.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till måndagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 Åtta hästar kommer till start i Toulouses Grand Prix du Sud-Ouest (€200.000) på onsdag, däribland Jörgen Westholms <strong>Ninepoints Lasse</strong> (e. Uncle Lasse).</p>



<p>Störst uppmärksamhet i loppet drar förstås de båda åttaåringarna <strong>Idao de Tillard</strong> (e. Severino) och <strong>Inexess Bleu</strong> (e. Vittel de Brevol), som tillsammans tjänat över 45 miljoner kronor och som båda fanns med i årets final av Elitloppet.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/04/atlantic1-617x425.jpg" alt="" class="wp-image-839755" style="width:660px;height:auto"/><figcaption class="wp-element-caption">Idao de Tillard omrigad av segerkusken Clément Duvaldestin och skötaren Susanne Ohme. Foto: Gerard Forni</figcaption></figure>



<p>För Idao de Tillard har perioden efter äventyret på Solvalla inneburit fyra raka segerar, i Prix Rene Balliere (€200.000), Prix de Washington (€120.000), Criterium de Vitesse de Basse-Normandie (€120.000) och Grand Prix Federation Regionale du Nord (€120.000).</p>



<p>Inexess Bleu kommer från galoppmisslyckande i Mons, men vann innan dess Prix Jean-Luc Lagardere (€150.000), samt slutade tvåa bakom Idao de Tillard i La Capelle i Grand Prix Federation Regionale du Nord.</p>



<h2 class="wp-block-heading">Startlista Grand Prix du Sud-Ouest (€200.000)</h2>



<p>2.750 meter, autostart</p>



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



<ol class="wp-block-list">
<li><strong>Filou d’Anjou</strong> (e. Othello Bourbon) – Eric Beaudard</li>



<li><strong>Jeannette Priory</strong> (e. Tag Wood) – Tony Le Beller</li>



<li><strong>Hymne du Gers</strong> (e. Bold Eagle) – Nicolas Bazire</li>



<li><strong>Fakir Merite</strong> (e. Uaukir) – Franck Marty</li>



<li><strong>Idao de Tillard </strong>(e. Severino) – Thierry Duvaldestin</li>



<li><strong>Inexess Bleu</strong> (e. Vittel de Brevol) – Laurent-Claude Abrivard</li>



<li><strong>Ideal du Rocher</strong> (e. Clif du Pommereux) – Thierry Duvaldestin</li>



<li><strong>Ninepoints Lasse </strong>(e. Uncle Lasse) – Jörgen Westholm</li>
</ol>



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



<p class="has-drop-cap">5 Den kanadensiska hästsporten vill att landets regering ändrar skattereglerna för hästägare. Bakgrunden är nya amerikanska skattelättnader som gör det betydligt mer fördelaktigt att investera i tävlingshästar söder om gränsen. Detta rapporterade standardbredcanada.com om igår.</p>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/trumppatrottbanamedhast-e1759078092724-617x546.jpg" alt="" class="wp-image-773273" style="width:395px;height:auto"/><figcaption class="wp-element-caption">Donald Trumps Big Beautiful Bill skapar goda förutsättningar för<br> hästsporten i USA. I Kanada vill man ha samma skattelättnader.</figcaption></figure>



<p>Frågan har nu uppmärksammats på nationell nivå i Kanada. I ett inslag i CTV News fredagen den 16 oktober berättade företrädare för hästsporten i Ontario om de ekonomiska skillnaderna mellan Kanada och USA. Genom president Donald Trumps skattereform, Big Beautiful Bill, har amerikanska hästägare fått möjlighet att dra av hela inköpspriset för en tävlingshäst vid beskattningen.</p>



<p>I Kanada ser situationen annorlunda ut. Enligt paragraf 31 i landets inkomstskattelag är avdragsmöjligheterna begränsade till maximalt 17.500 kanadensiska dollar. Bakgrunden är att skattelagstiftningen behandlar hästägare som deltidsverksamma hobbylantbrukare snarare än företagare.<br>– Vi bedriver affärsverksamhet. Det här är en kommersiell näring, säger Mark Halloran, vd för Canuck Racing Club, till CTV News.</p>



<p>Den helt kanadensiska ägarorganisationen för galopphästar ser sig nu tvingad att etablera verksamhet även i USA.<br>– Inom de närmaste veckorna kommer vi att vara verksamma i USA, säger Halloran.</p>



<p>Glenn Sikura, invald i Canadian Horse Racing Hall of Fame, är också kritisk till skillnaderna.<br>– Det är inte konkurrens på lika villkor överhuvudtaget. Jag är övertygad om att vi redan har förlorat tusentals arbetstillfällen.</p>



<p>Problemet berör såväl trav- som galoppsporten. Tillgången på tävlingshästar i Kanada är redan en utmaning och de amerikanska skattefördelarna riskerar enligt branschföreträdarna att ytterligare förstärka utflödet av hästar till USA.</p>



<p>Bill Ford, vice vd med ansvar för tävlingsverksamheten inom Woodbine Entertainment, anser att förändrade skatteregler skulle kunna bidra till både fler hästar och fler arbetstillfällen i Kanada.<br>– Vi måste stoppa flödet av hästar till USA som sedan aldrig kommer tillbaka. Det finns en lösning och den är inte särskilt komplicerad. Ändra paragraf 31, säger Ford.</p>



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



<p class="has-drop-cap">6 40.000 kronor i förstapris under en breddloppsdag? Solvallas inledande lopp under söndagen var vikt åt juniorerna i sporten och loppet där de tolv mest framgångsrika ungdomarna samlades gick under namnet Sweden International Yearling Sales Juniorchans Sulkyfinal. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/prettyeffectmam261018adamstromstalltz-617x401.jpg" alt="" class="wp-image-912650"/><figcaption class="wp-element-caption">Mio Arneng vinner med Pretty Effect. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Segrande körsven blev <strong>Mio Arneng</strong>, som i och med triumfen bakom Paul Hagoorts fyraåriga sto <strong>Pretty Effect</strong> (e. Bar Hopping), tog årets 28:e seger i 73:e försöket. Imponerande siffror för unge Arneng, som har en segerprocent på 38 så här långt i år, medan hans platsprocent ligger på 75!<br>– Det här trodde man ju inte när jag började köra lopp. Jag kunde inte tro att jag skulle få köra så här många lopp och det är bara att njuta. Idag var jag faktiskt lite nervös inför loppet, då jag fick chansen att köra åt en så pass stor tränare som Paul Hagoort, sade Mio Arneng i segerintervjun efter loppet.</p>



<p>Noterbart från Solvallas breddloppsdag är också att Eskilstunalärlingen <strong>Simon Helm</strong> vann fyra av de övriga nio loppen som stod på programmet. </p>



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



<p class="has-drop-cap">7 En norsk realityserie om trav är på gång, meddelade <a href="https://tgn.no/pilotepisoden-er-klar-viaplay-neste-stopp/19.37994" target="_blank" rel="noreferrer noopener">Trav Og Galopp-nytt</a> igår söndag. Ett pilotavsnitt är producerat och det är produktionsbolaget Screen Story som står bakom avsnittet, vilket förhoppningsvis ska väcka intresse hos ett tv-bolag.</p>



<p>– Pilotavsnittet, som är ett kortare avsnitt på 20 minuter, är i stort sett färdigt. Vi har fått besked från produktionsbolaget att de ska presentera idén, tillsammans med två andra förslag, för Viaplay vid ett möte under oktober. Det kallas ”höstjakten” i tv-branschen, där flera produktionsbolag presenterar sina idéer. Screen Story har stor erfarenhet av att producera den här typen av tv-serier. Det ska bli oerhört spännande, säger Bjerkes Hilde Apneseth.</p>



<p>– Jag har ännu inte sett den färdiga piloten, men ska få den skickad till mig så snart den är klar. Produktionsbolaget börjar med Viaplay eftersom de bedömer att möjligheterna att få gehör är störst där. Viaplay har en del realityserier som skildrar människors arbetsliv. Dessutom har Screen Story tidigare producerat flera framgångsrika serier för Viaplay, säger Apneseth.</p>



<p>Om Viaplay tackar nej kommer produktionsbolaget att gå vidare till andra tv-bolag, exempelvis TV 2.</p>



<p>Pilotavsnittet har finansierats gemensamt av Bjerke, DNT och Rikstoto, med visst ekonomiskt stöd från en filmfond i Rogaland.</p>



<p>– Det är lättare att få in en fot hos tv-kanalerna om vi själva är med och delfinansierar serien. I så fall får jag plocka fram mina gamla kunskaper som mediesäljare och se om vi kan få in pengar från sponsorer eller andra som brinner för sporten. Det blir nästa steg. Före jul bör vi ha ett besked, säger Apneseth.</p>



<p><strong>Björn Steine</strong>,<strong> Marcus Totland Aadland</strong> och <strong>Kristian Malmin</strong> är några av de medverkande i pilotavsnittet.</p>
