
<p class="has-drop-cap">1Förra sommaren bjöd på flera matcher i storloppen mellan hästar från Daniel Wäjerstens och Daniel Redéns stall. Till exempel i Årjängs Stora Sprinterlopp, där Wäjersten drog längsta strået med <strong>Gio Cash</strong> (e. Victor Gio) som krossade löpningsrekordet när han vann på 1.08,5a/1.640 meter före Redéns <strong>Don Fanucci Zet</strong> (e. Hard Livin) på 1.08,6.</p>



<p>Gio Cash är tillbaka för att försvara sin titel.<br>– Jag hoppas att hästen ska vara lika bra som förra året. Det var en oerhörd prestation. Han vann några storlopp ifjol sommar och jag tycker att hästen håller samma nivå, så jag hoppas att han ska visa sig från sin bästa sida, sade Daniel Wäjersten till ATG Live.</p>



<p>Redén kontrar med en trio från stallet – och för första gången kör han <strong>Francesco Zet</strong> (e. Father Patrick) i lopp.<br>– Han känns bra nu igen och har varit fin även om han inte kommer vara i toppform. Distansen är ju heller inte hans bästa, men läget är bra och Francesco går aldrig att räkna bort. När inte ”Tarzan” (Stefan Melander) fick köra honom så vill jag prova honom själv i ett lopp och det ska bli jäkligt roligt. Det blir barfota runt om och bike, säger Daniel Redén på sin hemsida <a href="http://reddis.se" target="_blank" rel="noreferrer noopener">reddis.se</a>.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/07/11v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Årjängs tävlingar idag.</a></p>



<p><strong>Snabbaste vinnarna av Årjängs Stora Sprinterlopp</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2025 <strong>Gio Cash</strong> (e. Victor Gio) – Daniel Wäjersten – 1.08,5</li>



<li>2018 <strong>Nadal Broline</strong> (e. Yankee Glide) – Ulf Ohlsson (Reijo Liljendahl) – 1.09,3</li>



<li>2019 <strong>Uza Josselyn</strong> (e. Love You) – Erik Adielsson (Rene Aebischer) – 1.09,3</li>



<li>2013 <strong>Sebastian K.</strong> (e. Korean) – Åke Svanstedt – 1.09,6</li>



<li>2017 <strong>Dante Boko</strong> (e. Going Kronos) – Adrian Kolgjini (Lutfi Kolgjini) – 1.09,6</li>



<li>2016 <strong>Nuncio</strong> (e. Andover Hall) – Örjan Kihlström (Stefan Melander) – 1.09,7</li>



<li>2021 <strong>Vernissage Grif</strong> (e. Varenne) – Alessandro Gocciadoro – 1.09,7</li>



<li>2020 <strong>Milligan’s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander) – 1.09,8</li>



<li>2014 <strong>Magic Tonight</strong> (e. Andover Hall) – Johan Untersteiner (Roger Walmann) – 1.09,9</li>
</ul>



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



<p class="has-drop-cap">2Årjäng (första start 14.35) bjuder på mer än banans stora sprinterlopp. Som dubbelcupens final för kallblodsston med 200.000 kronor till vinnaren. Loppet – Erik Persson Memorial – har körts sedan 1942 då <strong>Ovak</strong> vann med Folke Hjalmarsson i vagnen. Samma år tog Hjalmarsson hem det allsvenska körsvenschampionatet.</p>



<p>Jan-Olov Persson-tränade <strong>Prinsessan Stöen</strong> (e. Bork Odin) är favorit i loppen och en av omgångens mest betrodda hästar. Däremot är hon inget spikförslag från Sulkysportas expertpanel, där fyra experter plockar ut sin bästa spik och ett skrällbud.<br><em>”<strong>Secret Brigadoon</strong> spetsade från exakt samma läge näst senast över samma långa distans då som nu. Vann då enkelt till slut. Senast fastnade han med till synes rubbet sparat i ryggar och såg fortsatt formstark ut. Nu är motstånd, distans och utgångsläge nästan perfekt och det här leder Goop runt om. Spiken hamras in utan tvekan,” </em>säger en av experterna om sitt val av singelstreck.</p>



<p>Det kommer medhåll från tränaren och kusken Björn Goop.<br>– Secret Brigadoon var med i lördags i Halmstad, men hade inget flyt alls och satt fast. 1.640 meter är en bra distans och spår fem är ett bra spår. Jag tycker att han ska rankas etta i loppet, säger Goop i Björnkollen.</p>



<p><a href="https://sulkysport.se/spelstugan/v85-tips-ar-11-juli/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Årjängs V85-omgång.</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/simsalabim/V85_2026-07-11_31_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V85_2026-07-11_31_5" target="_blank" rel="noreferrer noopener">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-07-11_31_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</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/05/7goonboy2-617x333.jpg" alt="" class="wp-image-856512"/><figcaption class="wp-element-caption">Go On Boy och Romain Derieux vinner försöket i Elitloppet 2026. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3Förra året vann han Prix de Washington på Parisbanan Enghien på löpningsrekordet 1.08,6a/1.609 meter och i Elitloppsfinalen travade han 1.07,3a/1.609 meter som trea bakom <strong>Allegiant</strong> och <strong>Dream Mine</strong>. I eftermiddag är Romain Derieux stjärna <strong>Go On Boy</strong> (e. Password) en av fyra Elitloppshästar i det franska sprinterloppet.</p>



<p>Förutom Go On Boy finns nämligen även årets Elitloppsdeltagare <strong>Idao de Tillard</strong> (e. Severino), <strong>Keep Going</strong> (e. Follow You) och <strong>Jabalpur</strong> (e. Booster Winner) bland de elva deltagarna i en högklassig upplaga av det franska ”sommarmästerskapet” över sprinterdistans.</p>



<p>Romain Derieux är nöjd med Frankrikes genom tiderna snabbaste travare för dagen.<br>– Jag tycker att han är i god form, han verkar ha återhämtat sig bra från Elitloppet. Beslutet att hoppa över René Ballière, för att ge honom lite mer tid, var medvetet eftersom loppet bara var tre veckor efter. Det här är ju riktiga lopp; han är tio år gammal, och som jag alltid säger, jag försöker hålla honom igång så länge som möjligt, säger Derieux till 24H au Trot.</p>



<p>Han har redan skissat för resten av säsongen för sin stjärna.<br>– Planen är att börja med Prix de Washington. Sedan skulle vi helst åka till Cagnes i slutet av augusti. Det är Mons i september, sedan UET-finalen i oktober i Italien. Det kommer att bli ett bra program, särskilt eftersom han ligger bra till i poängligan, vilket gör att vi kan välja en bra startposition, säger Derieux som inte heller utesluter en sista satsning mot vintermeetinget och Prix d’Amérique.</p>



<p><strong>Alla vinnare under 1.10 i Prix de Washington</strong><br><em>År, häst (far) – Segertid</em></p>



<ul class="wp-block-list">
<li>2025 <strong>Go On Boy</strong> (e. Password) – 1.08,6a</li>



<li>2018 <strong>Uza Josselyn</strong> (e. Love You) – 1.09,0a</li>



<li>2023 <strong>Etonnant</strong> (e. Timoko) – 1.09,3a</li>



<li>2024 <strong>Hohneck</strong> (e. Royal Dream) – 1.09,3a</li>



<li>2012 <strong>Rapide Lebel</strong> (e. Ginger Somolli) – 1.09,4a</li>



<li>2007 <strong>Meaulnes du Corta</strong> (e. Voici du Niel) – 1.09,6a</li>



<li>2021 <strong>Go On Boy</strong> (e. Password) – 1.09,6a</li>



<li>2020 <strong>Drole de Jet</strong> (e. Coktail Jet) – 1.09,8a</li>



<li>2005 <strong>Jag de Bellouet</strong> (e. Vikings Way) – 1.09,9a</li>



<li>2016 <strong>Un Mec d’Heripre</strong> (e. Orlando Vici) – 1.09,9a</li>
</ul>



<p>Prix de Washington saknar svenskt deltagande liksom de två andra loppen öppna för alla européer, som körs utan svenska tränare i startlistan. Två svenskfödda travare startar i alla fall i fyra- och femåringsloppet Prix de Villers (€53.000). Erwin Bot tränar <strong>Force of Nature</strong> (e. Brillantissime), medan Laurent Claude Abrivard är mannen bakom <strong>Mister Lion</strong> (e. Mister J.P.).</p>



<p><a href="https://www.letrot.com/courses/programme/2026-07-11/7502" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens 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/2025/09/apexup2250730adamstromstalltz-617x433.jpg" alt="" class="wp-image-770481"/><figcaption class="wp-element-caption">Apex. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">4Första avdelningen av Meadowlands Delvin Miller Memorial ($141.900) för treåriga ston ser sex hästar bakom startbilen, samtliga tränade av svenskar och där Marcus Melanders och Stall Courants <strong>Nezuko Kamado S</strong> (e. Chapter Seven-Zefira Kronos) lär bli favorit till segern.<br>Nezuko Kamado S vann sex av elva starter som tvååring och är obesegrad efter tre starter i år. Över 720.000 dollar har inkasserats hittills i karriären och Scott Zeron kommer att köra stoet från spår ett bakom bilen. </p>



<p>Övriga svensktränade hästar i loppet är <strong>Leading Lady</strong> (e. Walner), Nancy Takter, <strong>Southwind Chaska</strong> (e. Tactical Landing), Jim Oscarsson, <strong>All Time Trot</strong> (e. Googoo Gaagaa), Åke Svanstedt, <strong>Days Away</strong> (e. Muscle Hill), Per Engblom och <strong>Lainey W</strong> (e. Bar Hopping), Marcus Melander.</p>



<p>Andra avdelningen av Delvin Miller Memorial ($143.500) känns på förhand inte alls lika tuff som det föregående loppet. Sju ston, varav fyra svensktränade, gör upp om segern och den av SRF Stable delägda <strong>Ygritte</strong> (e. Gimpanzee-Etta Am) jagar karriärens sjunde seger i sjunde försöket. Marcus Melander tränar och broder Mattias sitter i sulkyn bakom Ygritte, som bland annat får möta stallkamraten Creator (e. Walner), Svanstedts <strong>Isabella Bi</strong> (e. Tactical Landing) och Nancy Takters <strong>Sh’e Moni</strong> (e. Walner).</p>



<p>Marcus Melander har det väl förspänt även när treåriga hingstar och valacker gör upp i två avdelningar av Stanley Dancer Memorial ($145.900) på Meadowlands ikväll. <strong>Spencer Hanover</strong> (e. Chapter Seven-Secret Passion) och <strong>Nix Nacken</strong> (e. Muscle Hill-Nixie Volo) stöter på Chris Beavers <strong>Endurance</strong> (e. Captain Corey-Love Session) och Linda Toscanos <strong>It Could Be Worse</strong> (e. Captain Corey-Emilliciousboomboom).<br>Kulldominanten <strong>Apex</strong> (e. Walner-Mission Brief) slutade tvåa bakom <strong>Conversano</strong> i ett kvallopp förra veckan och lär ha goda möjligheter att ta hem andra avdelningen av Stanley Dancer Memorial ($144.650). Stallkamraten <strong>American Power</strong> (e. Walner-Ariana G) har tre segrar på fyra starter i år och ny kusk bakom hingsten blir James MacDonald idag.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/wb070426r8ontonorway-617x346.jpg" alt="" class="wp-image-870148"/><figcaption class="wp-element-caption">Invändige On To Norway håller undan för utvändige Super Chapter på nytt världsrekord. Foto: Lisa Photo</figcaption></figure>



<p>425.000 dollar står på spel när Hambletonian Maturity över 1,125 engelsk mil för fyraåriga travare och där blir det ett minst sagt spännande möte mellan segermaskinerna <strong>On To Norway</strong> (e. Muscle Massive-One Class Act) och <strong>Super Chapter</strong> (e. Chapter Seven-Lifetime Pursuit), vilka möttes på Meadowlands i lördags och där den förstnämnde drog det längsta strået på 1.07,5a/1.609 meter.</p>



<p><strong>Startlista Hambletonian Maturity ($425.000)</strong><br><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li><strong>Miracle Maven</strong> (e. Don’t Let’Em) – Ron Burke</li>



<li><strong>Walspea</strong> (e. Walner) – Trond Smedshammer</li>



<li><strong>Eurobank Hanover</strong> (e. Greenshoe) – Luc Blais</li>



<li><strong>Gimpanzee Dancer</strong> (e. Gimpanzee) – Chris Beaver</li>



<li><strong>Delaney Hanover</strong> (e. Muscle Hill) – Lucas Wallin</li>



<li><strong>Super Chapter</strong> (e. Chapter Seven) – Marcus Melander</li>



<li><strong>R Dutchess</strong> (e. Father Patrick) – John Butenschoen</li>



<li><strong>On To Norway</strong> (e. Muscle Massive) – Ron Burke</li>



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



<li><strong>Monserrate</strong> (e. Chapter Seven) – Andrew Harris</li>



<li><strong>Go Dog Go</strong> (e. Greenshoe) – Carter Pinske</li>



<li><strong>Greenma</strong> (e. Greenshoe) – Trond Smedshammer</li>



<li><strong>Meshuggah</strong> (e. Greenshoe) – Marcus Melander</li>
</ol>



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



<p class="has-drop-cap">5Vilket är Bollnästravets bästa ekipage? Ja, svaret ges nog inte ikväll (första start 17.05), men Bollnäsmästaren kan ge en fingervisning. Bollnäsmästaren för varm- och kallblod är öppet för hästar tränade i Bollnäs och körda av kuskar med licens vid banan. Loppet avgjordes för första gången 2020 och bjuder 50.000 kronor till vinnaren i varje lopp.</p>



<p>Tio hästar utspridda på fyra volter gör upp i varmblodsklassen, där den både mest meriterade och kanske mest formstarke jagar ensam från 60 meters tillägg. Linus Lönn sitter upp bakom Stefan Arvidsson-tränade <strong>Reven Dejavu</strong> (e. Revenue). som passerat två miljoner kronor insprunget i karriären under året. Tre segrar har det blivit för hästen som kom till Bollnästränare Arvidsson för nästan exakt ett år sedan.<br>På kallblodssidan sluter tolv hästar upp och loppets ende miljonär, Dennis Larsson-tränade <strong>Höstbo Wille</strong> (e. Tekno Odin), har en svettig uppgift med 100 meters tillägg tillsammans med Tomas Pettersson.</p>



<p>Ett fint fyraåringslopp för kallblod med flera hästar med Derbykvalen i Östersund den 27 juli i sikte bjuds det också i Bollnäs. En som dock inte får mäta krafterna i kallblodsklassikern är en av kullens bästa hästar, <strong>G.G.Xtrem</strong> (e. Grisle Odin G.L.) som tränas av Olov Brunlöf. Hästen är nämligen inte anmäld.<br>G.G.Xtrem vann Prinsessan Madeleines Pokal i Bollnäs i maj och blev dessutom avelsgodkänd ifjol som treåring. Nu jagar han från 40 meters tillägg femte segern i elfte starten.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/07/11v5.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bollnäs tävlingar ikväll.</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/2021/09/devilstongue-617x333.jpg" alt="" class="wp-image-212498"/><figcaption class="wp-element-caption">Sandra Eriksson och Devils Tongue.. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">6På norska travbanan Harstad långt upp i norr väntar årets enda norska V75-omgång på banan. Det lockar långväga, svenska gäster och hela 21 svensktränade hästar finns med i programmet.</p>



<p>Flest har trogne Harstadresenären Bert Pettersson med Skellefteå som hemmabana. Han reser med nio hästar till Harstad, där han tidigare i år redan tagit åtta av stallets 20 vinster.</p>



<p>I kvällens största lopp – Ole Bendiksens Minne med 100.000 kronor i förstapris – har han fältets två rikaste hästar i Selmer I.H. (e. Love You) och Bravo Sabotage (e. From Above). Dessa utmanas främst av Sandra Erikssons Devils Tongue (e. Zola Boko) och Hanna Olovsson-tränade Last Dying Breath (e. Nuncio).</p>



<p><strong>Här är de svenska tränarnas hästar i Harstad:</strong></p>



<ul class="wp-block-list">
<li><strong>Sandra Eriksson (2):</strong> Devils Tongue (Sandra Eriksson), B.Sacamanro (Sandra Eriksson)</li>



<li><strong>Hanna Olofsson (6):</strong> Kerryman (Hanna Olofsson), Last Dying Breath (Hanna Olofsson), Bornunderthunder (Hanna Olofsson), Enjoy Beaufort (Jenny Engfors), Beast (Marcus Totland Aadland), Ja Ba Da Ba Doooo (Hanna Olofsson)</li>



<li><strong>Bert Pettersson (9):</strong> Tangen Tore (Sigmund Jakobsen), Schuster (Hans Christian Holm), Xanthis Illusion (Sigmund Jakobsen), Bravo Sabotage (Hans Christian Holm), Selmer I.H. (Sigmund Jakobsen), Scotch Bonnet (Adrian Solberg Akselsen), Sweet Candyman (Sigmund Jakobsen), Grand Safari (Hans Christian Holm), Billy The Bronco (Hans Christian Holm)</li>



<li><strong>Madelene Wikstén (4): </strong>Ben Hogan (Lisa Näsvall), Crazy Nolimit (Henrik Näsvall), Killing Pace (Henrik Näsvall), Infinite Mass (Henrik Näsvall)</li>
</ul>



<p><a href="https://www.travsport.no/travbaner/harstad-travpark/startlist/2026-07-11" target="_blank" rel="noreferrer noopener">Här är startlistorna till Harstads tävlingar.</a></p>



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



<p class="has-drop-cap">7Jonas Czernyson bötfälls med 2.000 dollar och stängs av i tio dagar sedan en av hans hästar – <strong>Chosen Prayer</strong> – testat positivt för flufenazin efter seger på Oak Grove den 9 juni.</p>



<p>Den behandlande veterinärens redovisning (hade räknat fel på dagar) vägdes in som en förmildrande omständighet.<br>Jonas Czernyson är avstängd mellan den 16 och 25 juli och dessutom går Chosen Prayers ägare miste om förstapriset på 7.000 dollar. </p>
