
<p class="has-drop-cap wp-block-paragraph">1Den 3 februari 1992 vände Karl-Gösta Fylking upp och segerdefilerade på hemmabanan med <strong>Pagan</strong> (e. Crowning Point) efter karriärens 1.169:e seger. Då sade hjärtat stopp, han föll ur sulkyn och 55 år gammal hade en av svensk travsports stora profiler hastigt ryckts bort.</p>



<p class="wp-block-paragraph">Karl-Gösta Fylking – eller ”Korpen” – var en skicklig hästkarl som gick hem i alla läger. Hans popularitet var stor med glimten i ögat och som humörspridare, och för publiken blev han ”småspelarnas vän”.</p>



<p class="wp-block-paragraph">1955 vann han sitt första lopp med Sigrun, som tränades av pappa Gösta. Den seger skulle följas av många fler. Bland storloppsvinsterna finns Svenskt Travderby (Guy Nibs 1967), Svenskt Trav-Oaks (Divina Tilly 1981), (Sprintermästaren (Pelle J:r 1973) och Svenskt Mästerskap (Speedy Min 1980). Som tränare var dubbelmiljonären och elithästen Hanzie V. (född 1981 e. Second Boy) hans kanske bästa häst.</p>



<p class="wp-block-paragraph">En anekdot signerad travjournalisten Sven ”Harper” Carlström: 1987 startade stoet Sigrun och hennes dotter Mahogny i samma lopp. Pappa Gösta körde Sigrun och Kalle satt bakom Mahogny! Mor och dotter kördes av far och son alltså.</p>



<p class="wp-block-paragraph">1960 vann Kalle Fylking lärlingsfinalen Guldklockan på Solvalla och när Solvalla efter ”Korpens” bortgång skapade ett minneslopp var det ett lärlingslopp som gällde. Sedan 1993 när Göran Frank vann med <strong>Bold Sprinter</strong> (e. Bold Vigil) har Karl-Gösta Fylkings Minneslopp avgjorts varje år på huvudstadsbanan. B- och K-licensierade kuskar med Solvallalicens, anställda av proffs- eller amatörtränare, får köra loppet och ikväll är det dags för årets upplaga!</p>



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



<p class="has-drop-cap wp-block-paragraph">2Gösta Fylkings Minneslopp tar plats på V86-kupongen när Solvalla (första start 18.15) delar expresstravet med Åby (första start 18.27) i denna jackpotkryddade omgång. Prognosen säger att åttarättspotten ska innehålla 20 miljoner kronor.</p>



<p class="wp-block-paragraph">Loppet är en spårtrappa öppet för hästar upp till 2,5 miljoner intjänat och har lockat en del starka namn.</p>



<p class="wp-block-paragraph">Både Daniel Wäjerstens <strong>Heartbeat Thunder </strong>(e. Scarlet Knight) och Kim Pedersens jänkare <strong>Hell Patrol </strong>(e. Yankee Glide) har årsdebuten svklarad och starka fjolårssäsonger bakom sig. Hell Patrol hade en fin vinter och vår förra året och testades i både Copenhagen Cup och Oslo Grand Prix, innan han drabbades av gaffelbandsskada efter det sistnämnda loppet.</p>



<p class="wp-block-paragraph">På Solvalla i övrigt står en plats i montéeliten på spel i Solvalla Hästägarförenings Montépokal, där vinnaren får – förutom 100.000 kronor i förstapris – även en biljett till sadelloppet på Elitloppsdagen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/04/24v86.pdf" class="">Här kan du ta del av dagens startlistor till tävlingarna på Solvalla och Åby.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3Per K Erikssons topphäst<strong> Lozano di Quattro </strong>(e. Trixton) har fått två lugna genomkörare – och vinster – i början av säsongen och något liknande ser det ut att bli ikväll på Åby, där sexåringen dragit fjärdespår bakom bilen i ett sprinterlopp och blir svårslagen igen.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/11/lozanodiquattro-617x333.jpg" alt="" class="wp-image-379322"/><figcaption class="wp-element-caption">Per Eriksson-tränade Lozano di Quattro är redo för årets tredje start. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Den mest meriterade motståndaren är fjolårets norske Derbyvinnare <strong>Born In Bergen </strong>(e. Born in the U.S.A.), som också har två lopp i kroppen när han gör sin första start på svensk mark. Han tränas av Kim Pedersen – som också är mannen bakom den på Solvalla tävlande Hell Patrol.</p>



<p class="wp-block-paragraph">I ett treåringslopp utanför V86-kupongen gör mångfaldige Grupp I-vinnaren Vivid Wise As lillebror <strong>Far Wise As</strong> (e. Face Time Bourbon) årsdebut i Jerry Riordans regi. En segrar och två andraplatser var resultatet på tre starter som tvååring. Nu ställs han bland annat mot Uppfödningsvinnaren Bythebooks lillasyster, Per Nordström-tränade <strong>Zipzeronada</strong> (e. Googoo Gaagaa), som inlett säsongen med två segrar. </p>



<p class="wp-block-paragraph">Sulkysports spelstuga med analyser, spikar, drag och favoriter i fara på V86 publiceras som vanligt kl 12.00 idag.</p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-04-24_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206235_V86_2024-04-24_40_1" class="">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Svenska hästar lyser med sin frånvaro på fransk mark denna onsdag när det körs ett penningstint lopp i Cordemais (första start kl. 13.55).</p>



<p class="wp-block-paragraph">Det handlar om den fjärde etappen av Grand National du Trot (€90.000) där de 16 deltagarna står placerade över tre olika volter och där favoritskapet lär komma att delas mellan Florent Lamares<strong> Galago du Cadran</strong> (e. Amiral Sacha) och Franck Leblancs <strong>Ibiki de Houelle</strong> (e. Love You).</p>



<p class="wp-block-paragraph">Det står 40.500 euro på spel till vinnaren och i Cordemais tävlas det i vänstervarv på en bana som mäter 1.240 meter i omkrets.</p>



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



<p class="has-drop-cap wp-block-paragraph">5Tre uttagningslopp till Arvid Åvallin TammaDerby (€8.800) för finländska, femåriga ston avgörs på Vermo (första start kl. 17.06) denna onsdagskväll med nio deltagare i varje.</p>



<p class="wp-block-paragraph">De fyra främsta tar sig vidare till finalen som avgörs på Vermo lördag den 4 maj med 52.800 euro i samlad prissumma varav 24.000 euro går till vinnaren.</p>



<p class="wp-block-paragraph">Katja Melkko är den enda svensklicenserade tränaren som har ett bidrag i loppet och då handlar det om<strong> Loulou Web</strong> (e. Like A Prayer) som körs av Antti Teivanen från ett åttondespår i det inledande uttagningsloppet.</p>



<p class="wp-block-paragraph">Hon drabbar samman med Markku Nieminens <strong>Halley Wania</strong> (e. E L Titan) som tillsammans med Hannu-Pekka Korpis <strong>Ava di Alessia</strong> (e. Express Duo) är de enda hästarna som kvalar i kvällens lopp att ha tjänat över 100.000 euro.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Långluffaren <strong>Digital Summit </strong>(e. Super Photo Kosmos) 1.11,0ak/1.773.000 kr har bytt regi efter ett och ett halvt år i Joakim Lövgrens regi.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/digitalsummitjlm221226adamstromstalltz-617x405.jpg" alt="" class="wp-image-395544"/><figcaption class="wp-element-caption">Digital Summit och Joakim Lövgren vid seger i Hästägarkannan. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Där vann den nu åttaårige valacken Hästägarkannan på Solvalla med 300.000 kronor i segerpremie och under fjolåret tjänade han likaså sexsiffrigt vid ett tillfälle då han vann Majstayern på Jägersro med 100.000 kronor i vinstsumma.</p>



<p class="wp-block-paragraph">Nu har Mattias Djuse tagit över träningen av hästen som inlett året med en seger på fyra starter.</p>



<p class="wp-block-paragraph">Ny regi är det även på det fyraåriga stoet<strong> F.B.I.</strong> (e. Nuncio) 1.13,7ak/154.500 kr som tidigare tävlat för Claes Sjöström.<br>Under fjolåret vann hon ett treåringslopp på Solvalla under våren, men det var också årets enda seger på åtta försök.<br>Numera finns stoet hos Halmstadproffset Håkan K Persson.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Inga träd växer till himlen. Det fick Alessandro Gocciadoro erfara då hans efter sex starter obesegrade treåringsstjärna Falco Killer Gar (e. Varenne) gick på pumpen för första gången vid gårdagskvällens tävlingar i italienska Modena.</p>



<p class="wp-block-paragraph">Från innerspår bakom bilen blev hingsten över från start och slog på en galopp i första kurvan liksom fjolårets tvåfaldige Grupp I-tvåa Fil Ek (e. Ringostarr Treb).</p>



<p class="wp-block-paragraph">Segern i Premio Puglia (€12.650) gick istället till Enrico Belleis <strong>Fortunadrago Font</strong> (e. Quite Easy U.S.) vilken han själv kuskade in till seger på 1.14,2a/2.080 meter efter att gett hästen ett avvaktande lopp och först satt in attacken på upploppet.</p>

Fokustema
Morgonsvepet
Läs senare
Småspelarnas vän hyllas
Om kvällens hyllningslopp till "Korpen", derbyvinnaren som ska utmana svensk topphäst på Åby och om dagens Grupp-lopp i franska Cordemais kan du bland annat läsa i veckans tredje morgonsvep.
