
<p class="has-drop-cap wp-block-paragraph">Ett hemmahopp spikas inom lördagens jackpotkryddade V75-omgång när det vankas stora pengar på spel i Sundsvall.</p>



<p class="wp-block-paragraph">Prognosen säger att sjurättspotten ska innehålla 75 miljoner kronor och det piskar givetvis upp spelvärdet i omgången även om det i ärlighetens namn finns flera starka favoriter.</p>



<p class="wp-block-paragraph">Vi tänker på <strong>High On Pepper</strong> (V75-3) som ser ut att ha en straffspark i en svag upplaga av halvmijonloppet Bergsåker Winter Trot, men tar även ställning för favoriten <strong>L.A.Boko </strong>(V75-5) i Silverdivisionen. Det kan vi dock få betalt för då det är ett lopp där många lär sprida streck på mellan tre till sex hästar och det ger oss utrymme för att gardera några andra tunga pjäser.</p>



<p class="wp-block-paragraph">Omgångens svåraste lopp bedömer vi utan tvivel kallblodsloppet för ston (V75-2) till att vara. <strong>Dån Klara </strong>har alla möjligheter att lösa uppgiften om hon får spara speeden, men konkurrens saknas på intet vis utan här är det flera om budet.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/02/17v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Bergsåker.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-02-17_9_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-02-17_9_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2024-02-17_9_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Klass II, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Ever Loving </strong>var en dyring då han såldes på Menhammar Sales som ettåring och gick loss på 1.125.000 kronor. Femåringen har långt kvar tills han tjänat ihop de pengarna och har två STL-försök bakom sig denna vinter varav det som bäst slutat med en tredjeplats i Klass II från dödens, men att han ska duga riktigt bra i konkurrensen tvivlar vi inte på. Får Ulf Ohlsson träff från springspår är chansen god att hästen antingen tar ledningen av egen kraft eller övertar i tidigt skede.</li>



<li><strong>The Flying Eagle </strong>är också en starkt stammad femåring vars mor Denim Boko vann såväl Svensk Uppfödningslöpning som Svampens stoklass som tvååring. The Flying Eagle började karriären tilltalande, men därefter gick det i stå och det var glädjande att se hur fin han var i debuten för Mattias Djuse senast på Romme. Konkurrensen var dock mer än lovligt klen och hästen fick löpa ut i ledningen, men vi är övertygade om att högstanivån är så pass att han ska duga även i STL-sammanhang.</li>



<li><strong>Oracle Vixi </strong>släppte ledningen senast på Solvalla och blev kvar med sparade krafter. Han är härdad i tuff onsdagskonkurrens och det här motståndet behöver inte nödvändigtvis vara tuffare.</li>



<li><strong>Staro Royal Mark </strong>fick se sig regelrätt besegrad från ledningen av Northman Maxus senast på Solvalla, men var på intet vis dålig. Han slog aldrig av på farten helt utan gjorde så gott han kunde och kan må gott av att få jaga bakifrån nu en gång.</li>



<li><strong>Lightzon</strong> har varit lärling- eller amatörkörd i karriärens 23 starter. Nu stärker Erik Adielsson upp i sulkyn vilket givetcis är ett stort plus och hästen kommer därtill från en smått övertygande spurtseger, om än i enklare sällskap.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6-11-2 <strong>B: </strong>10-4-7-3-8-12 <strong>C: </strong>9-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Forbidden to Rest</strong> är spetsfavorit, men är springspårskonkurrenten <strong>Ever Loving </strong>med på noterna och snabbt framme på hans utsida så tror vi att han får överta per omgående.</p>



<h2 class="wp-block-heading">Avd 2 – Kallblodslopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Dån Klara</strong> fick jaga från fjärde utvändigt sista kilometern senast i Bollnäs och lägga en tuff speed ut på sista bortre långsidan. Vi tycker att hon föll med flaggan i topp och gjorde en väl så bra insats som vinnaren Ethel. Dån Klara kan gynnas av att det är ett halvvarv kortare distans i det här loppet och blir väldigt svår att stå emot om hon får spara speeden lite längre.</li>



<li><strong>Bork Tindra </strong>gick helt okej senast i Gävle efter en dryg månads tävlingsuppehåll. Den starten bör rimligtvis föra henne framåt och här är hon spetsfavorit i lag med Magnus A Djuse som därefter får ta sig en funderare på om han vill fullfölja i den positionen eller släppa till Ethel om den sistnämnda kommer fram tidigt på utsidan.</li>



<li><strong>Ethel </strong>valde Henrik Svensson att flytta fram till dödspositionen vid mötet med Dån Klara i Bollnäs och låste på så vis loppet. Ethel stod för en toppinsats och skulle hon nu lyckas komma före Dån Klara direkt och forceras till tät i ett tidigt skede så kan resultat bli detsamma som vid just mötet i Bollnäs.</li>



<li><strong>Åse Mona </strong>var gott gåendes när hon blev störd till galopp 300 meter före mål senast i Bollnäs. Vi utesluter inte alls att hon hade gett Ethel och Dån Klara en riktigt match om segern den dagen och ser henne som en av de hetare kandidaterna här då upploppet på Bergsåker är gynnsamt långt.</li>



<li><strong>Klack Nova </strong>besegrade Dån Klara i Gävle i slutet av fjolåret, men fick ett försprång då i slutkurvan som inte gick att plocka in. Den här uppgiften känns tuffare på pappret.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 8-1-6<strong> B: </strong>10-12-2-14-3-4-15 <strong>C: </strong>7-9-5-11-13</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Bork Tindra </strong>har jättechans att fronta i första skedet och det krävs nog att <strong>Ethel</strong> kommer tidigt för att det över huvud taget ska övervägas att släppa ledningen.</p>



<h2 class="wp-block-heading">Avd 3 – Bergsåker Winter Trot, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>High On Pepper </strong>har övertygat stort vintern igenom och sannerligen inte radat upp sex raka triumfer på grund av tur. Hästen har verkligen utvecklats på alla plan och var med så pass bra från början senast att han kunde forceras till tät efter 700 meter. Konkurrenterna bör rimligtvis ha stor respekt för honom vid det här laget och vi tror att han vinkas fram och får överta taktpinnen ånyo och då talar allt för att han håller hela vägen.</li>



<li><strong>Demon</strong> var ute i Grupp I-loppet Prix Bold Eagle senast på Vincennes och såg inte trött ut när galoppen kom 550 meter före mål. Däremot så gick det väldigt fort i det skedet och han fick slita för att slå följe i det uppskruvade tempot. Gången innan stod hästen för en toppinsats som tvåa i Sylvesterloppet på Axevalla, men då stod han 20 meter före High On Pepper som vann loppet och nu handlar det trots allt om lika start.</li>



<li><strong>Phoenix Photo</strong> fick en het häst på utsidan senast i Bollnäs och det var inget att säga något om att han fick se sig nerplockad över spurtrakan. Totalt sett har hästen utvecklats på alla områden och då mycket talar för att han vinner starten här och kan överlämna taktpinnen – om så önskas – till favoriten så kommer han sitta bra till inför spurten.</li>



<li><strong>Axel Ruda </strong>gick en rejäl 700 metersrepa vid guldsegern i Bollnäs och befäste att den goda vinterformen håller i sig. Han lär få ta upp jakten från de bakre regionerna även här, men bredden är inte märkvärdig i det här loppet och vi blir överraskade om han inte slutar bland de fyra främsta.</li>



<li><strong>Ferrari Sisu </strong>vann Salatrofén i Eskilstuna i november, men har inte visat samma toppform efter det. Distansen talar till hästens fördel och spår åtta kan han leva med då han ändå inte är någon startraket utan brukar hamna i de bakre regionerna.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 3 <strong>B: </strong>9-6-11-8-10<strong> C:</strong> 1-7-5-2-4</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Över den här distansen så tror vi att man släpper med <strong>Phoenix Photo</strong> till <strong>High On Pepper</strong> om Jorma Kontio kommer fram i ett tidigt skede.</p>



<h2 class="wp-block-heading">Avd 4 – Diamantstoet, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Crazy Life </strong>var kraftigt uppammäld senast då hon startade i Stoeliten. Jorma Kontio vek ner stoet på innerspår direkt och sparade alla meter han kunde, men när väl luckan kom på spurtrakan så sköt hon till riktigt tilltalande. Det var en klart bra insats och även om Crazy Life inte har någon seger i resultatraden så tycker vi att hon gjort det bra under vintern. I mer beskedlig omgivning kan det vara hennes tur.</li>



<li><strong>Jade Sisu </strong>körde Conrad Lugauer fullt naturligt snällt med i comebacken och det gav också resultat. Stoet växlade ner sina konkurrenter på snyggt sätt över spurtrakan och det var ett helpiggt intryck som stoet gav då hon sprang och spelade med öronen över spurtrakan. Tar hon det loppet på rätt sätt och rentav går framåt lite ytterligare så matchar hon även detta sällskap.</li>



<li><strong>Vilja T.Y.C. </strong>stötte på just Jade Sisu senast på Solvalla. Hon kördes också väldigt snällt och låg länge och väl sist i fältet, men avslutningen till tredjeplatsen var av bästa märke. Kan hon återigen spara speeden fram tills spurtrakan så är hon med i segerstriden.</li>



<li><strong>Shehuntyoudown</strong> gick en rejäl långspurt senast i Gävle och höll mycket bra som tvåa bakom Underbaråsofin. Stoet börjar så smått komma i fjolårets hysteriska vinterform och är inte golvad.</li>



<li><strong>West Wind</strong> fick gå utan rygg på slutrundan senast i Östersund i krävande förutsättningar. Hon tog striden väl och det kittlar att hon har innerspår på tillägg här och kan ges en spårsnål smygresa.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>9-13-10 <strong>B: </strong>14-8-6-1-15-3-4 <strong>C: </strong>11-2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Öppet, men Tomas Pettersson är en duktig startkusk och nu när <strong>Exactement</strong> är ensam på springspår talar de faktorerna till hennes fördel.</p>



<h2 class="wp-block-heading">Avd 5 – Silverdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>L.A.Boko</strong> tog Daniel Wäjersten en lugn start med senast i Bollnäs och avancerade fram utvändigt om ledaren <strong>Cab Frontline </strong>efter hand. Därifrån var han bara bäst och vi undrar om vi sett L.A.Boko se så fin ut någon gång tidigare som han gjorde den dagen. Det var ett toppintryck och trots att han drog nitlotten här spårmässigt bland de som kommer bli mer betrodda så håller vi honom som favorit till att lösa uppgiften.</li>



<li><strong>Xanthis Hilton </strong>hamnade &#8221;helt åt råttorna&#8221; fel på det senast från spår åtta bakom bilen och fick backas ner i kön. Därifrån kom han aldrig till i stentuff konkurrens och det var ingenting att säga något om. Stefan Melanders femåringar har dessförinnan radat upp starka vinterprestationer och det faktum att han är ny i Silverdivisionen är inget som skrämmer oss.</li>



<li><strong>Kayla Westwood </strong>fick nöja sig med tredje invändigt från spår ett senast i Stoeliten på Solvalla. Luckan kom sent, men Maharajah-dottern var med på noterna direkt och sköt till fint som trea bakom Decision Maker och Betting Pacer. Skulle hon få ett rygglopp ånyo och spara speeden i det här lilla fältet så är hon med och strider om segern.</li>



<li><strong>Parveny</strong> var bra vid segern i ett överpacat lopp i januari och satt fast med sparade krafter i senaste starten. Når han ledningen här komemr han sälja sig dyrt.</li>



<li><strong>G.R.J.&#8217;s Wolverine </strong>slog det inte gnistor om senast i Silverdivisionsfinalen, men har annars gjort bra insatser i vinter. Han är inte het nog för att få plats i vår A-grupp, men tillhör tillsammans med Cab Frontline kategorin där bakom av tänkbara vinnare.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>7-5-4-6<strong> B: </strong>1-2 <strong>C: </strong>3-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Cab Frontline</strong> och <strong>Xanthis Hilton </strong>aspirerar på att nå ledningen, men får verkligen skynda sig om de ska kunna hålla ut <strong>Parveny</strong>.</p>



<h2 class="wp-block-heading">Avd 6 – Klass I, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Judge Dredd Sisu </strong>flög till ledningen från spår sex vid näst senaste starten på Sundbyholm och vann lekande lätt. Gången efter hade han innerspår i Gävle och taktade till så pass när startbilen skulle släppa farten att han blev över från början. Mika Forss litade dock på sin hästs styrka och att jobba på i dödspositionen under slutrundan var inget hinder för femåringen. Lyckas hästen forceras till tät ånyo trots snabba hästar på insidan sitter han verkligen på trumf.</li>



<li><strong>Erjon</strong> fick ett tufft lopp i Klass I i Bollnäs och gick sig trött på kuppen. Det fick han även senast på Sundbyholm då han fick nöta dödens, men konkurrensen var klart enklare och hästen visade god uppfattning som satte nosen först på mållinjen. Skulle han lyckas hålla ut vårt tipsval initialt så kan loppet vara hans, men även från vinnarhålet är Erjon aktuell.</li>



<li><strong>Benchmark</strong> hamnade i en trött rygg senast på Åby och blev dragen bakåt. Luckan kom sent och den av Stefan Melander-tränade femåringen följde med lättsamt i slutskedet utan att se ut att gå sig tom. Benchmark är aktuell för slutstrid i det här loppet om han &#8221;bara&#8221; kan undvika dödspositionen.</li>



<li><strong>Never To Young </strong>har inlett året med tre raka segrar, om än i enklare omgivning. Hon har dock varit rejäl och det kittlar att Per Lennartsson växlar upp nu och har anmält stoet med jänkarvagn för första gången.</li>



<li><strong>Luca di Quattro </strong>tog ner ledaren från dödens senast på Bergsåker, men fick se sig spurtslagen av <strong>Bounced</strong> stegen före mål. Han var stor i nederlaget och är minst en outsider i det här sällskapet.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3-1-5 <strong>B: </strong>4-10-2-7-12-11-8<strong> C: </strong>6-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Erjon </strong>och <strong>Kattens Aladin</strong> är hetaste kandidaterna, men även <strong>Judge Dredd Sisu</strong> lär vilja ha ett ord med i laget. <strong>Extremly Sweet</strong> och<strong> Magical Survivor </strong>kanske är explosivast initialt av samtliga framspårshästar, men skickas de verkligen med full kraft från spår längst ut bakom vingen?</p>



<h2 class="wp-block-heading">Avd 7 – Bronsdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>It&#8217;s Peppertime</strong> stod för en stark comebackinsats i Bollnäs och var sannerligen inte sämre senast i finalen. Då blev det dock ett knalltufft lopp med tredjespår utan rygg hela slutvarvet samtidigt som farten skruvades upp och det var inget att säga något om att han inte kunde blanda sig i slutstriden. Hästen föll med flaggan i topp och står bättre till här, men risken att han får vandra i dödens är påtaglig.</li>



<li><strong>King of Djazz </strong>fick gnugga på som förstahäst i andraspår vid V75-segern senast på Umåker och var klart rejäl. Sandra Eriksson har fått härlig snurr på den här hästen som tycks utvecklas hela tiden. Nu gör han sin första start på närmare två månader varpå det föreligger formfrågetecken, men Bodentränaren skulle knappast sända ut honom inom STL om han inte är förberedd. Därtill är chansen god att han kommer före sin värsta konkurrent direkt.</li>



<li><strong>Wings Level</strong> var inte långt efter It&#8217;s Peppertime vid mötet i Bollnäs och har därefter räknat hem en dödensvinst i lite enklare sällskap. Han står sig bra i den här klassen och har alla möjligheter att blanda sig i segerstriden.</li>



<li><strong>Itso Sisu </strong>gör jämna, gedigna insatser hela tiden utan att segrarna duggar tätt. Han kan få ett vilsamt lopp längs sargen här och känns inte golvad om det bara löser sig till slut.</li>



<li><strong>Jewilla</strong> gick sig rejält trött från ledningen i Diamantstoets final senast och kan må gott av att få anfalla bakifrån den här gången.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3-6 <strong>B: </strong>7-1-9-2-12-8-11 <strong>C: </strong>5-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Inga riktiga raketer utöver<strong> Mission Beach</strong>. Vi kan se Marcus Lilius testa och köra henne i ledningen nu om inte <strong>King of Djazz</strong> eller <strong>It&#8217;s Peppertime</strong> kommer fram och ställer en tidig fråga.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 17 FEBRUARI								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>2,4,6,10,11 (7,3)<br><strong>Avd 2: </strong>1,2,3,6,8,10,12,14 (4,15)<br><strong>Avd 3: </strong>3 High on Pepper (9,6)<br><strong>Avd 4: </strong>6,8,9,10,13,14 (1,15)<br><strong>Avd 5: </strong>7 L.A.Boko (5,4)<br><strong>Avd 6: </strong>1,2,3,4,5,7,10,12 (11,8)<br><strong>Avd 7: </strong>3,6 (7,1)</p>



<p class="wp-block-paragraph"><em>3.840 rader / 1.920 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
