
<p class="has-drop-cap">1 Ready Cash-sönerna <strong>Mellby Jinx</strong> och <strong>Baron Tilly</strong> är snabbaste vinnarna i Sverige över sprinterdistans – <strong>Francesco Zet</strong> vann Paralympiatravet över medeldistans på 1.09,5a – under 2026 med 1.09,6a/1.640 meter. Är det dags att putsa den noteringen ikväll i det femte av sju lopp i Solvallas E-loppsserie inför Elitloppet?</p>



<p>I så fall sker det i hyllningen till Torbjörn Janssons Elitloppsvinnare från 1985, då Meadow Roads lopp är namnet på kvällens sprinterlopp på <strong>Solvalla </strong>(första start 18.15). Där gör också överlägsne ledaren i E-loppsserien, Daniel Redén-tränade <strong>Don Fanucci Zet </strong>(e. Hard Livin), sin tredje start i serien efter att ha vunnit båda sina två tidigare försök.</p>



<p>Vägen till en tredje seger för numera genom E-loppen Elitloppsklare Don Fanucci Zet kan dock bli tuff från sjundespår bakom bilen. För en annan Elitloppshäst ser det bättre ut när Daniel Wäjestens <strong>Borups Victory </strong>(e. Googoo Gaagaa) är nedstruken till innerspår bakom bilen.</p>


<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Ställningen i E-loppen								</h3>
<div class="content">
<p><strong>Efter fyra lopp:</strong><br /><em>Häst – Tränare – Poäng</em></p>
<ul class="wp-block-list">
<li>Don Fanucci Zet – Daniel Redén – 30</li>
<li><strong>Diva Ek – Alessandro Gocciadoro – 15</strong></li>
<li>Francesco Zet – Daniel Redén – 15</li>
<li>Kuiper – Daniel Wäjersten – 8</li>
<li>Mellby Jinx – Daniel Wäjersten – 8</li>
<li>Parveny – Mattias Djuse – 8</li>
<li>Önas Prince – Per Nordström – 8</li>
<li>Gio Cash – Daniel Wäjersten – 6</li>
<li>High On Pepper – Katja Melkko – 6</li>
<li>Kentucky River – Daniel Redén – 6</li>
<li>Laredo Boko – Robert Bergh – 6</li>
<li><strong>A Fair Day – Elisabeth Almheden – 3</strong></li>
<li>Get A Wish – Robert Bergh – 3</li>
<li>Hades de Vandel – Paul Hagoort – 3</li>
<li>Xanthis Harvey – Daniel Redén – 3</li>
<li>Following – Stefan Melander – 2</li>
<li>Gamin Jaba – Daniel Redén – 2</li>
<li>Luke The Spook – Adrian Kolgjini – 2</li>
<li>Stens Rubin – Johan Untersteiner – 2</li>
<li>Eolo Jet – Alessandro Gocciadoro – 1</li>
<li>Joe Dalton – Stefan P Pettersson – 1</li>
<li>Macahan – Maria Törnqvist – 1</li>
<li>Charron – Geir Vegard Gundersen – 1</li>
</ul>
<p><strong>Hästar i fet stil är redan inbjudna till/klara för Elitloppet 2026.</strong></p>
<p><strong>Fotnot: </strong>Poäng utgår till de sex främsta hästarna enligt skalan: 15-8-6-3-2-1.<br />Vid lika poäng avgör antal starter i loppen. Vid lika antal starter avgör lottning.<br />De två främsta i serien får en biljett till Elitloppet.</p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p><strong>Axevalla</strong> (första start 18.27) delar kvällens V86-spel med Solvalla och Maria Törnqvist har en femårig klassklättare i <strong>Danville </strong>(e. Tactical Landing). Efter blott tre starter förra året har hästen som valack kommit tillbaka på bästa sätt i år och ståtar nu med fyra raka segrar.</p>



<p>Ska det bli ett staket i resultatraden ska Danville lösa uppgiften från åttondespår i volten och bland annat hålla undan 20 meter för gode <strong>Kipketer Mearas</strong> (e. S.J.’s Caviar) från Ulf Stenströmers stall.</p>



<p>––> Sulkysports expertpanel bjuder som vanligt på bästa spikarna och skrällbuden till V86 och dessa presenteras vid lunchtid idag.</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/V86_2026-05-13_40_1" class="">Här finns andelar till V86 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V86_2026-05-13_40_1" class="">Här finns andelar till V86 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V86_2026-05-13_40_1" class="">Här finns andelar till V86 hos Spelpoolen.</a></p>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/04/nightflightbgm260422adamstromstalltz.jpg" alt="" class="wp-image-841594"/><figcaption class="wp-element-caption">Marcus Schön-tränade Night Flight debutvann för Björn Goop. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">2 Hela nio obesegrade treåringar dyker upp i fyra olika lopp på kvällens båda banor Solvalla och Axevalla. Den snabbaste av dem har till och med hunnit vinna två gånger hittills i karriären, Geir Vegard Gundersens svenskfödde <strong>Rubert Boko </strong>(e. Tactical Landing), som vid sitt första Sverigebesök i senaste starten vann på 1.14,4/2.140 meter voltstart efter en 1.11-avslutning från ledningen.</p>



<p>Nederländaren Paul Hagoort mönstrar två obesegrade debutvinnare på Solvalla och svenskfödde <strong>Västerbo Sparkly </strong>(e. Djjango Riff) ställs mot <strong>Rubert Boko</strong>, liksom Björn Röcklingers debutvinnare<strong> Intro </strong>(e. Readly Express).</p>



<p>Italienska stoet <strong>Ifigenia of Brown</strong> (e. Walner) ör Hagoorts andra bidrag och denna ställs mot Per Nordströms Gordon <strong>Gekko </strong>(e. Googoo Gaagaa).</p>



<p>På Axevalla möts också en obesegrad trio i Svensk Travsports unghästserie för treåriga ston i form av Marcus Schöns <strong>Night Flight </strong>(e. Gimpanzee), Gustav Johanssons <strong>Madame</strong> (e. Vivid Wise As), samt <strong>Trendy Zon </strong>(e. Maharajah) från Maria Törnqvists stall. Den sistnämnda mönstrar också<strong> G.K.Many Trix </strong>(e. Very Kronos), som vunnit livets enda start hittills, mot äldre hästar.</p>



<p>Hittills i år har drygt 150 svensktränade treåriga varmblod vunnit lopp i Sverige. Flest segrar har Claes Sjöströms sto <strong>Icy Conditions </strong>(e. Calgary Games), som vunnit samtliga fem starter under 2026.</p>



<p>På kallblodssidan har 14 treåringar vunnit lopp i Sverige i år.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/05/13v86.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/05/13v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens 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/2021/09/claessjostrom2-617x333.jpg" alt="" class="wp-image-219579"/><figcaption class="wp-element-caption">Claes Sjöström fyller 50 år. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3 Idag fyller Solvallatränaren Claes Sjöström 50 år och han blev medlem nummer 100 i Tusenklubben den 13 november 2020.</p>



<p>Första segern tog Claes Sjöström 1997 med <strong>Carl von Silver</strong> i Lindesberg som 19-åring. Hans 1.000:e seger togs på hemmabanan Solvalla 2020 med <strong>Matamoros</strong>.</p>



<p>Ifjol hade Claes Sjöström sitt bästa år i karriären. Han körde in drygt 19 miljoner kronor och vann 120 lopp och som tränare gjorde han också sin bästa säsong med 9,3 miljoner och 70 segrar.</p>



<p>Claes Sjöström har 13 championtitlar på Visbytravet, varav tio på raken. Han har också fyra kuskchampionat på Mariehamn och ett tränarchampionat på Gävletravet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/bedazzledsoxcsm240814adamstromstalltz-617x400.jpg" alt="" class="wp-image-621899"/><figcaption class="wp-element-caption">Bedazzled Sox och Claes Sjöström vinner Margareta Wallenius-Klebergs Pokal. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Största segern i karriären är vinsten med Roger Walmann-tränade <strong>Bedazzled Sox</strong> i Margareta Wallenius-Klebergs Pokal (f.d. Jubileumspokalen) på Solvalla 2024.</p>



<p>När det gäller tränarsegrar sticker <strong>Aisle Stands</strong> triumf ut i Solvalla Grand Prix 2011 och <strong>She’s From Aboves</strong> vinst i Guldstoet på Axevalla 2015.</p>



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



<p class="has-drop-cap">4 Sprinterloppet Gran Premio Renzo Orlandi (€55.000) avgörs på söndag i Modena och dit åker Björn Goop för att köra Richard Westerinks <strong>Ideal San Leandro</strong> (e. Timoko).</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/05/bjorngooptumme.jpg" alt="" class="wp-image-722879"/><figcaption class="wp-element-caption">Björn Goop åker till Modena på söndag. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Alessandro Gocciadoro har som vanligt väl förspänt och stallet startar tre hästar; <strong>Dali Prav</strong>, <strong>East Asia</strong> och <strong>Fellow Wise As</strong>.</p>



<p>I måndags kunde Sulkysport berätta om Alessandro Gocciadoros makalösa framgångar i Grupp-löpningar i en <a href="https://sulkysport.se/kronika/den-gule-vaxlar-upp/" data-type="link" data-id="https://sulkysport.se/kronika/den-gule-vaxlar-upp/" target="_blank" rel="noreferrer noopener">krönika</a>.</p>



<p><strong>Gran Premio Renzo Orlandi </strong>(€55.000)<br>Äldre hästar.<br><em>1.600 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Deus Zack</strong> (e. Victor Gio) – Edoardo Loccisano</li>



<li><strong>Fellow Wise As</strong> (e. Maharajah) – Gennaro Riccio</li>



<li><strong>Emma del Veltri</strong> (e. Maharajah) – Enrico Bellei</li>



<li><strong>East Asia </strong>(e. Ready Cash) – Antonio di Nardo</li>



<li><strong>Fil Ek</strong> (e. Ringostarr Treb) – Pietro Gubellini</li>



<li><strong>Dali Prav </strong>(e. Donato Hanover) – Rene’ Legati</li>



<li><strong>Ideal San Leandro</strong> (e. Timoko) – Björn Goop</li>



<li><strong>Dana Ek </strong>(e. Vivid Wise As) – Andrea Guzzinati</li>



<li><strong>Dylan Dog Font </strong>(e. Ringostarr Treb) – Andrea Farolfi</li>



<li><strong>Eclatante Se</strong> (e. Maharajah) – Marco Stefani</li>



<li><strong>Far West Bi </strong>(e. Muscle Hill) – Gabriele Gelormini</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/prixmartha2-617x410.jpg" alt="" class="wp-image-839648"/><figcaption class="wp-element-caption">Eminent Kronos spurtar till seger för Franck Nivard. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap">5 Fem av åtta lopp är öppna för europa-födda travare på <a href="https://www.letrot.com/courses/programme/2026-05-13/7500" data-type="link" data-id="https://www.letrot.com/courses/programme/2026-05-13/7500" target="_blank" rel="noreferrer noopener">Vincennes</a> idag (första start kl. 13.55) och åtta blågula travare dyker upp på den franska huvudstadsovalen.</p>



<p>Redan i det inledande loppet – Prix du Perreux (€90.000) – startar Dominik Locqueneux duon <strong>Nelson Greenwood </strong>(e. Tobin Kronos) och <strong>Omerta Boko</strong> (e. Face Time Bourbon).</p>



<p>Vincent Martens-tränade <strong>Lisbeth Dry</strong> (e. Trixton) går ut i Prix de Nice (€41.000), Jörgen Westholms <strong>Indy Rock</strong> (e. Readly Express) tävlar i Prix du Gatinais (€90.000), Johan Untersteiners <strong>Eminent Kronos (</strong>e. Propulsion) jagar femte raka segern i Prix d’Aire sur l’Audour (€53.000) och där möter han Erik Bondos <strong>Pure Steel </strong>(e. Bird Parker).</p>



<p>Avslutningsvis startar Dion Tesselaar <strong>Moni Making Pace </strong>(e. International Moni) och <strong>Peaky Blinder Boko </strong>(e. Robert Bi) i Prix de Fecamp (€52.000) och där plockar också Sabine Kagebrant ut franskfödda <strong>Mabellissime</strong> (e. Love You).</p>



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



<p class="has-drop-cap">6 Tidigare under dagen åker Jarmo Niskanen till <a href="https://www.letrot.com/courses/programme/2026-05-13/6701" data-type="link" data-id="https://www.letrot.com/courses/programme/2026-05-13/6701" target="_blank" rel="noreferrer noopener">Strasbourg</a> (första start kl. 11.05) för att starta <strong>King Elvis </strong>(e. Bold Eagle) i Prix de Selestat (€22.000) över 2.800 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/jasmineising-617x333.jpg" alt="" class="wp-image-213998"/><figcaption class="wp-element-caption">Jasmine Ising. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>I Strassbourg startar också Jasmine Isings <strong>Ferrox Brick</strong> (e. Orlando Vici) i Prix du Muguet (€32.000) och i samma lopp dyker också svenskfödde <strong>Rossi Garline</strong> (e. Readly Express) och Stall Escapades <strong>General du Nord</strong> (e. Un Mec d’Heripre) upp.</p>



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



<p class="has-drop-cap">7 Nedskalade kasinoplaner. Jeffrey Gural, ägare till Meadowlands, signalerar nu en kursändring för framtida kasinon i norra New Jersey.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/meadowlandsgrandstandscjessicahallett1024-617x348.jpg" alt="" class="wp-image-848940"/><figcaption class="wp-element-caption">Meadowlands kämpar fortsatt med sina kasinoplaner.</figcaption></figure>



<p>Istället för de storslagna lyxresorter som kännetecknar Atlantic City föreslår Gural en mer nedskalad modell med fokus på bekvämlighet och lokala spelare.</p>



<p>Huvudsyftet med de reviderade planerna är att fånga upp de stora summor pengar som New Jersey-bor idag spenderar i grannstaterna. Med de nya kasinosatsningarna i New York City och den redan etablerade marknaden i Pennsylvania, läcker New Jersey stora skatteintäkter varje månad.</p>



<p>Förslaget om kasinon i norra New Jersey har länge mött hårt motstånd från intressenter i Atlantic City, som fruktar att deras monopol i delstaten ska urholkas och leda till ekonomisk nedgång i södern.</p>
